From a78a826668c407dfe477de2817024a8917695f97 Mon Sep 17 00:00:00 2001 From: Anton Tayanovskyy Date: Thu, 7 Sep 2023 15:32:23 -0400 Subject: [PATCH 1/4] Update Pulumi to 3.81.0 --- provider/go.mod | 19 +++++++++++++++---- provider/go.sum | 39 ++++++++++++++++++++++++++++++++------- sdk/go.mod | 19 ++++++++++++++++--- sdk/go.sum | 42 +++++++++++++++++++++++++++++++++++------- tests/go.mod | 19 +++++++++++++++---- tests/go.sum | 39 ++++++++++++++++++++++++++++++++------- 6 files changed, 145 insertions(+), 32 deletions(-) diff --git a/provider/go.mod b/provider/go.mod index df528ce5f3..5d9d7ccea9 100644 --- a/provider/go.mod +++ b/provider/go.mod @@ -12,8 +12,8 @@ require ( github.com/mitchellh/mapstructure v1.5.0 github.com/pkg/errors v0.9.1 github.com/pulumi/cloud-ready-checks v1.0.1-0.20230201174945-00fe9c1b68fd - github.com/pulumi/pulumi/pkg/v3 v3.78.1 - github.com/pulumi/pulumi/sdk/v3 v3.78.1 + github.com/pulumi/pulumi/pkg/v3 v3.81.0 + github.com/pulumi/pulumi/sdk/v3 v3.81.0 github.com/stretchr/testify v1.8.3 golang.org/x/crypto v0.9.0 google.golang.org/grpc v1.57.0 @@ -85,7 +85,7 @@ require ( github.com/docker/go-connections v0.4.0 // indirect github.com/docker/go-metrics v0.0.1 // indirect github.com/docker/go-units v0.5.0 // indirect - github.com/dustin/go-humanize v1.0.0 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect github.com/emirpasic/gods v1.18.1 // indirect github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d // indirect github.com/fatih/color v1.13.0 // indirect @@ -143,7 +143,7 @@ require ( github.com/mailru/easyjson v0.7.7 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.18 // indirect - github.com/mattn/go-runewidth v0.0.13 // indirect + github.com/mattn/go-runewidth v0.0.14 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect github.com/mitchellh/copystructure v1.2.0 // indirect @@ -244,6 +244,7 @@ require ( github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect github.com/armon/go-metrics v0.4.0 // indirect github.com/armon/go-radix v1.0.0 // indirect + github.com/atotto/clipboard v0.1.4 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.3 // indirect github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.21 // indirect github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.27 // indirect @@ -253,7 +254,12 @@ require ( github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.10 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.13.9 // indirect github.com/aws/aws-sdk-go-v2/service/s3 v1.27.2 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/charmbracelet/bubbles v0.16.1 // indirect + github.com/charmbracelet/bubbletea v0.24.2 // indirect + github.com/charmbracelet/lipgloss v0.7.1 // indirect github.com/cloudflare/circl v1.3.3 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect github.com/docker/cli v20.10.21+incompatible // indirect github.com/edsrzf/mmap-go v1.1.0 // indirect github.com/emicklei/go-restful/v3 v3.10.1 // indirect @@ -277,8 +283,13 @@ require ( github.com/hashicorp/yamux v0.1.1 // indirect github.com/klauspost/compress v1.16.0 // indirect github.com/kylelemons/godebug v1.1.0 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect github.com/mitchellh/go-testing-interface v1.14.1 // indirect + github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b // indirect github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.1 // indirect github.com/natefinch/atomic v1.0.1 // indirect github.com/oklog/run v1.1.0 // indirect github.com/pjbgf/sha1cd v0.3.0 // indirect diff --git a/provider/go.sum b/provider/go.sum index 11a2511bd1..08501a20c4 100644 --- a/provider/go.sum +++ b/provider/go.sum @@ -274,6 +274,8 @@ github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:l github.com/asaskevich/govalidator v0.0.0-20200907205600-7a23bdc65eef/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d h1:Byv0BzEl3/e6D5CLfI0j/7hiIEtvGVFPCZ7Ei2oq8iQ= github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0= github.com/aws/aws-sdk-go v1.15.27/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0= @@ -334,6 +336,8 @@ github.com/aws/aws-sdk-go-v2/service/sts v1.16.10/go.mod h1:cftkHYN6tCDNfkSasAmc github.com/aws/smithy-go v1.12.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= github.com/aws/smithy-go v1.13.5 h1:hgz0X/DX0dGqTYpGALqXJoRKRj5oQ7150i5FdTePzO8= github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= github.com/benbjohnson/clock v1.0.3/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= @@ -381,6 +385,12 @@ github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chai2010/gettext-go v1.0.2 h1:1Lwwip6Q2QGsAdl/ZKPCwTe9fe0CjlUbqj5bFNSjIRk= github.com/chai2010/gettext-go v1.0.2/go.mod h1:y+wnP2cHYaVj19NZhYKAwEMH2CI1gNHeQQ+5AjwawxA= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY= +github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg= +github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E= +github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c= github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw= github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E= @@ -444,6 +454,8 @@ github.com/containerd/console v0.0.0-20191206165004-02ecf6a7291e/go.mod h1:8Pf4g github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw= github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ= github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= github.com/containerd/containerd v1.2.10/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.3.0-beta.2.0.20190828155532-0293cbd26c69/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.3.0/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= @@ -613,8 +625,9 @@ github.com/docker/libtrust v0.0.0-20150114040149-fa567046d9b1/go.mod h1:cyGadeNE github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM= github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= @@ -1299,6 +1312,8 @@ github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0U github.com/linode/linodego v1.4.0/go.mod h1:PVsRxSlOiJyvG4/scTszpmZDTdgS+to3X6eS8pRrWI8= github.com/linode/linodego v1.8.0/go.mod h1:heqhl91D8QTPVm2k9qZHP78zzbOdTFLXE9NJc3bcc50= github.com/linuxkit/virtsock v0.0.0-20201010232012-f8cee7dfc7a3/go.mod h1:3r6x7q95whyfWQpmGZTu3gk3v2YkMi05HEzl7Tf7YEo= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= @@ -1344,12 +1359,15 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/ github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98= github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= github.com/mattn/go-oci8 v0.1.1/go.mod h1:wjDx6Xm9q7dFtHJvIlrI99JytznLw5wQ4R+9mNXJwGI= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU= +github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/mattn/go-shellwords v1.0.3/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= github.com/mattn/go-shellwords v1.0.6/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y= @@ -1436,8 +1454,14 @@ github.com/montanaflynn/stats v0.6.6/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b h1:1XF24mVaiu7u+CFywTdcDo2ie1pzzhwjt6RHqzpMU34= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho= github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.1 h1:UzuTb/+hhlBugQz28rpzey4ZuKcZ03MeKsoG7IJZIxs= +github.com/muesli/termenv v0.15.1/go.mod h1:HeAQPTzpfs016yGtA4g00CsdYnVLJvxsS4ANqrZs2sQ= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= @@ -1648,12 +1672,13 @@ github.com/prometheus/prometheus v0.37.0/go.mod h1:egARUgz+K93zwqsVIAneFlLZefyGO github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= github.com/pulumi/cloud-ready-checks v1.0.1-0.20230201174945-00fe9c1b68fd h1:shFTLvh3MZbBzVDr3xwYjUr5H1y3N5n4pczWtVaUZxo= github.com/pulumi/cloud-ready-checks v1.0.1-0.20230201174945-00fe9c1b68fd/go.mod h1:C6HmNtth9oPAWKyRJveZSU4rK/tvzhSGuoOV5y+S17g= -github.com/pulumi/pulumi/pkg/v3 v3.78.1 h1:5uLCVwaIToa7knWNpt33JGySkBsGEzzR+N6YXJxuNUU= -github.com/pulumi/pulumi/pkg/v3 v3.78.1/go.mod h1:4/0nD+7QHgUAPwypZ0RqGNuQmGSXHPbaUmsTU/U/Mzc= -github.com/pulumi/pulumi/sdk/v3 v3.78.1 h1:itSfMcILvEq5wOpGEAzeZdpH973yJ4sRn02nx5SCJHM= -github.com/pulumi/pulumi/sdk/v3 v3.78.1/go.mod h1:FEFictCHoa8CYzKDSc0t9ErrNiaO9n7pChreLQLDH+M= +github.com/pulumi/pulumi/pkg/v3 v3.81.0 h1:6rf2farQLszi8inHCu9YdJtDvK0fqNguix51b3FEDRQ= +github.com/pulumi/pulumi/pkg/v3 v3.81.0/go.mod h1:URXozJB/abhxb2yOwa5ywHjT2dqt9SmAX2iLkdcOOl0= +github.com/pulumi/pulumi/sdk/v3 v3.81.0 h1:d711GUpjZK1beNpIKFReC1LBmHXYE684sYWntJWQ4Q0= +github.com/pulumi/pulumi/sdk/v3 v3.81.0/go.mod h1:RMilNNVMlmK1h4Nl/qylb9vzbgh4F3mufZoUOnPy98o= github.com/rakyll/embedmd v0.0.0-20171029212350-c8060a0752a2/go.mod h1:7jOTMgqac46PZcF54q6l2hkLEG8op93fZu61KmxWDV4= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= diff --git a/sdk/go.mod b/sdk/go.mod index 85565c57b5..60678c63f5 100644 --- a/sdk/go.mod +++ b/sdk/go.mod @@ -5,7 +5,7 @@ go 1.21 require ( github.com/blang/semver v3.5.1+incompatible github.com/pkg/errors v0.9.1 - github.com/pulumi/pulumi/sdk/v3 v3.78.1 + github.com/pulumi/pulumi/sdk/v3 v3.81.0 ) require ( @@ -15,8 +15,14 @@ require ( github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect github.com/agext/levenshtein v1.2.1 // indirect github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect + github.com/atotto/clipboard v0.1.4 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/charmbracelet/bubbles v0.16.1 // indirect + github.com/charmbracelet/bubbletea v0.24.2 // indirect + github.com/charmbracelet/lipgloss v0.7.1 // indirect github.com/cheggaaa/pb v1.0.29 // indirect github.com/cloudflare/circl v1.3.3 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect github.com/djherbis/times v1.5.0 // indirect github.com/emirpasic/gods v1.18.1 // indirect github.com/go-git/gcfg v1.5.0 // indirect @@ -33,10 +39,16 @@ require ( github.com/inconshreveable/mousetrap v1.0.1 // indirect github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect github.com/kevinburke/ssh_config v1.2.0 // indirect - github.com/mattn/go-isatty v0.0.14 // indirect - github.com/mattn/go-runewidth v0.0.13 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-isatty v0.0.18 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.14 // indirect github.com/mitchellh/go-ps v1.0.0 // indirect github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect + github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.1 // indirect github.com/opentracing/basictracer-go v1.1.0 // indirect github.com/opentracing/opentracing-go v1.2.0 // indirect github.com/pjbgf/sha1cd v0.3.0 // indirect @@ -59,6 +71,7 @@ require ( go.uber.org/atomic v1.9.0 // indirect golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a // indirect golang.org/x/net v0.10.0 // indirect + golang.org/x/sync v0.1.0 // indirect golang.org/x/sys v0.8.0 // indirect golang.org/x/term v0.8.0 // indirect golang.org/x/text v0.9.0 // indirect diff --git a/sdk/go.sum b/sdk/go.sum index 7e379fa40c..22c9c0479d 100644 --- a/sdk/go.sum +++ b/sdk/go.sum @@ -16,14 +16,26 @@ github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6 github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY= +github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg= +github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E= +github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c= github.com/cheggaaa/pb v1.0.29 h1:FckUN5ngEk2LpvuG0fw1GEFx6LtyY2pWI/Z2QgCnEYo= github.com/cheggaaa/pb v1.0.29/go.mod h1:W40334L7FMC5JKWldsTWbdGjLo0RxUKK73K+TuPxX30= github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I= github.com/cloudflare/circl v1.3.3 h1:fE/Qz0QdIGqeWfnwq0RE0R7MI51s0M2E4Ga9kq5AEMs= github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -87,6 +99,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/matryer/is v1.2.0 h1:92UTHpy8CDwaJ08GqLDzhhuixiBUUD1p3AU6PHddz4A= github.com/matryer/is v1.2.0/go.mod h1:2fLPjFQM9rhQ15aVEtbuwhJinnOqrmgXPNdZsdwlWXA= github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= @@ -94,16 +108,27 @@ github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZb github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= -github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= -github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98= +github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU= +github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc= github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM= github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= github.com/mmcloughlin/avo v0.5.0/go.mod h1:ChHFdoV7ql95Wi7vuq2YT1bwCJqiWdZrQ1im3VujLYM= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b h1:1XF24mVaiu7u+CFywTdcDo2ie1pzzhwjt6RHqzpMU34= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.1 h1:UzuTb/+hhlBugQz28rpzey4ZuKcZ03MeKsoG7IJZIxs= +github.com/muesli/termenv v0.15.1/go.mod h1:HeAQPTzpfs016yGtA4g00CsdYnVLJvxsS4ANqrZs2sQ= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= github.com/opentracing/basictracer-go v1.1.0 h1:Oa1fTSBvAl8pa3U+IJYqrKm0NALwH9OsgwOqDv4xJW0= github.com/opentracing/basictracer-go v1.1.0/go.mod h1:V2HZueSJEp879yv285Aap1BS69fQMD+MNP1mRs6mBQc= @@ -118,8 +143,9 @@ github.com/pkg/term v1.1.0 h1:xIAAdCMh3QIAy+5FrE8Ad8XoDhEU4ufwbaSozViP9kk= github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pulumi/pulumi/sdk/v3 v3.78.1 h1:itSfMcILvEq5wOpGEAzeZdpH973yJ4sRn02nx5SCJHM= -github.com/pulumi/pulumi/sdk/v3 v3.78.1/go.mod h1:FEFictCHoa8CYzKDSc0t9ErrNiaO9n7pChreLQLDH+M= +github.com/pulumi/pulumi/sdk/v3 v3.81.0 h1:d711GUpjZK1beNpIKFReC1LBmHXYE684sYWntJWQ4Q0= +github.com/pulumi/pulumi/sdk/v3 v3.81.0/go.mod h1:RMilNNVMlmK1h4Nl/qylb9vzbgh4F3mufZoUOnPy98o= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= @@ -204,6 +230,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -218,7 +246,6 @@ golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -228,6 +255,7 @@ golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= diff --git a/tests/go.mod b/tests/go.mod index e8ca224f75..3209e48d0a 100644 --- a/tests/go.mod +++ b/tests/go.mod @@ -10,8 +10,8 @@ replace ( require ( github.com/pulumi/pulumi-kubernetes/provider/v4 v4.0.0 github.com/pulumi/pulumi-kubernetes/sdk/v4 v4.0.0 - github.com/pulumi/pulumi/pkg/v3 v3.78.1 - github.com/pulumi/pulumi/sdk/v3 v3.78.1 + github.com/pulumi/pulumi/pkg/v3 v3.81.0 + github.com/pulumi/pulumi/sdk/v3 v3.81.0 github.com/stretchr/testify v1.8.3 helm.sh/helm/v3 v3.12.1 k8s.io/apimachinery v0.27.2 @@ -62,6 +62,7 @@ require ( github.com/armon/go-metrics v0.4.0 // indirect github.com/armon/go-radix v1.0.0 // indirect github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d // indirect + github.com/atotto/clipboard v0.1.4 // indirect github.com/aws/aws-sdk-go v1.44.298 // indirect github.com/aws/aws-sdk-go-v2 v1.17.3 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.3 // indirect @@ -82,13 +83,18 @@ require ( github.com/aws/aws-sdk-go-v2/service/sso v1.11.13 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.16.10 // indirect github.com/aws/smithy-go v1.13.5 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/blang/semver v3.5.1+incompatible // indirect github.com/cenkalti/backoff/v3 v3.2.2 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/chai2010/gettext-go v1.0.2 // indirect + github.com/charmbracelet/bubbles v0.16.1 // indirect + github.com/charmbracelet/bubbletea v0.24.2 // indirect + github.com/charmbracelet/lipgloss v0.7.1 // indirect github.com/cheggaaa/pb v1.0.29 // indirect github.com/cloudflare/circl v1.3.3 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect github.com/containerd/containerd v1.7.0 // indirect github.com/cyphar/filepath-securejoin v0.2.3 // indirect github.com/davecgh/go-spew v1.1.1 // indirect @@ -101,7 +107,7 @@ require ( github.com/docker/go-connections v0.4.0 // indirect github.com/docker/go-metrics v0.0.1 // indirect github.com/docker/go-units v0.5.0 // indirect - github.com/dustin/go-humanize v1.0.0 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect github.com/edsrzf/mmap-go v1.1.0 // indirect github.com/emicklei/go-restful/v3 v3.10.1 // indirect github.com/emirpasic/gods v1.18.1 // indirect @@ -181,10 +187,12 @@ require ( github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect github.com/lib/pq v1.10.9 // indirect github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect github.com/mailru/easyjson v0.7.7 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.18 // indirect - github.com/mattn/go-runewidth v0.0.13 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.14 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect github.com/mitchellh/copystructure v1.2.0 // indirect @@ -201,7 +209,10 @@ require ( github.com/modern-go/reflect2 v1.0.2 // indirect github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect github.com/morikuni/aec v1.0.0 // indirect + github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b // indirect github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.1 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/natefinch/atomic v1.0.1 // indirect github.com/oklog/run v1.1.0 // indirect diff --git a/tests/go.sum b/tests/go.sum index c92371181f..f2e25c3285 100644 --- a/tests/go.sum +++ b/tests/go.sum @@ -271,6 +271,8 @@ github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:l github.com/asaskevich/govalidator v0.0.0-20200907205600-7a23bdc65eef/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d h1:Byv0BzEl3/e6D5CLfI0j/7hiIEtvGVFPCZ7Ei2oq8iQ= github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0= github.com/aws/aws-sdk-go v1.15.27/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0= @@ -331,6 +333,8 @@ github.com/aws/aws-sdk-go-v2/service/sts v1.16.10/go.mod h1:cftkHYN6tCDNfkSasAmc github.com/aws/smithy-go v1.12.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= github.com/aws/smithy-go v1.13.5 h1:hgz0X/DX0dGqTYpGALqXJoRKRj5oQ7150i5FdTePzO8= github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= github.com/benbjohnson/clock v1.0.3/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= @@ -378,6 +382,12 @@ github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chai2010/gettext-go v1.0.2 h1:1Lwwip6Q2QGsAdl/ZKPCwTe9fe0CjlUbqj5bFNSjIRk= github.com/chai2010/gettext-go v1.0.2/go.mod h1:y+wnP2cHYaVj19NZhYKAwEMH2CI1gNHeQQ+5AjwawxA= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY= +github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg= +github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E= +github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c= github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw= github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E= @@ -441,6 +451,8 @@ github.com/containerd/console v0.0.0-20191206165004-02ecf6a7291e/go.mod h1:8Pf4g github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw= github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ= github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= github.com/containerd/containerd v1.2.10/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.3.0-beta.2.0.20190828155532-0293cbd26c69/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.3.0/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= @@ -610,8 +622,9 @@ github.com/docker/libtrust v0.0.0-20150114040149-fa567046d9b1/go.mod h1:cyGadeNE github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM= github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= @@ -1291,6 +1304,8 @@ github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0U github.com/linode/linodego v1.4.0/go.mod h1:PVsRxSlOiJyvG4/scTszpmZDTdgS+to3X6eS8pRrWI8= github.com/linode/linodego v1.8.0/go.mod h1:heqhl91D8QTPVm2k9qZHP78zzbOdTFLXE9NJc3bcc50= github.com/linuxkit/virtsock v0.0.0-20201010232012-f8cee7dfc7a3/go.mod h1:3r6x7q95whyfWQpmGZTu3gk3v2YkMi05HEzl7Tf7YEo= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= @@ -1336,12 +1351,15 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/ github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98= github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= github.com/mattn/go-oci8 v0.1.1/go.mod h1:wjDx6Xm9q7dFtHJvIlrI99JytznLw5wQ4R+9mNXJwGI= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU= +github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/mattn/go-shellwords v1.0.3/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= github.com/mattn/go-shellwords v1.0.6/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y= @@ -1428,8 +1446,14 @@ github.com/montanaflynn/stats v0.6.6/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b h1:1XF24mVaiu7u+CFywTdcDo2ie1pzzhwjt6RHqzpMU34= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho= github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.1 h1:UzuTb/+hhlBugQz28rpzey4ZuKcZ03MeKsoG7IJZIxs= +github.com/muesli/termenv v0.15.1/go.mod h1:HeAQPTzpfs016yGtA4g00CsdYnVLJvxsS4ANqrZs2sQ= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= @@ -1639,12 +1663,13 @@ github.com/prometheus/prometheus v0.37.0/go.mod h1:egARUgz+K93zwqsVIAneFlLZefyGO github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= github.com/pulumi/cloud-ready-checks v1.0.1-0.20230201174945-00fe9c1b68fd h1:shFTLvh3MZbBzVDr3xwYjUr5H1y3N5n4pczWtVaUZxo= github.com/pulumi/cloud-ready-checks v1.0.1-0.20230201174945-00fe9c1b68fd/go.mod h1:C6HmNtth9oPAWKyRJveZSU4rK/tvzhSGuoOV5y+S17g= -github.com/pulumi/pulumi/pkg/v3 v3.78.1 h1:5uLCVwaIToa7knWNpt33JGySkBsGEzzR+N6YXJxuNUU= -github.com/pulumi/pulumi/pkg/v3 v3.78.1/go.mod h1:4/0nD+7QHgUAPwypZ0RqGNuQmGSXHPbaUmsTU/U/Mzc= -github.com/pulumi/pulumi/sdk/v3 v3.78.1 h1:itSfMcILvEq5wOpGEAzeZdpH973yJ4sRn02nx5SCJHM= -github.com/pulumi/pulumi/sdk/v3 v3.78.1/go.mod h1:FEFictCHoa8CYzKDSc0t9ErrNiaO9n7pChreLQLDH+M= +github.com/pulumi/pulumi/pkg/v3 v3.81.0 h1:6rf2farQLszi8inHCu9YdJtDvK0fqNguix51b3FEDRQ= +github.com/pulumi/pulumi/pkg/v3 v3.81.0/go.mod h1:URXozJB/abhxb2yOwa5ywHjT2dqt9SmAX2iLkdcOOl0= +github.com/pulumi/pulumi/sdk/v3 v3.81.0 h1:d711GUpjZK1beNpIKFReC1LBmHXYE684sYWntJWQ4Q0= +github.com/pulumi/pulumi/sdk/v3 v3.81.0/go.mod h1:RMilNNVMlmK1h4Nl/qylb9vzbgh4F3mufZoUOnPy98o= github.com/rakyll/embedmd v0.0.0-20171029212350-c8060a0752a2/go.mod h1:7jOTMgqac46PZcF54q6l2hkLEG8op93fZu61KmxWDV4= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= From c7bc5a3a930eb3ce90eb934052219fce7f841789 Mon Sep 17 00:00:00 2001 From: Anton Tayanovskyy Date: Thu, 7 Sep 2023 15:33:27 -0400 Subject: [PATCH 2/4] Remove temp Make code that is now part of pulumi/pkg logic --- scripts/build_python_sdk.sh | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/scripts/build_python_sdk.sh b/scripts/build_python_sdk.sh index 8047a95dae..d3590708aa 100755 --- a/scripts/build_python_sdk.sh +++ b/scripts/build_python_sdk.sh @@ -11,10 +11,6 @@ set -euo pipefail cd ./sdk/python -# Removing auto-generated setup.py; this is needed until there is an option on the SDK generator to -# opt out of generating this file. -rm setup.py - cat << EOF > go.mod module fake_python_module // Exclude this directory from Go tools @@ -28,17 +24,6 @@ mv ../python.bin ./bin sed -i.bak -e "s/^ version = .*/ version = \"$PYPI_VERSION\"/g" ./bin/pyproject.toml rm ./bin/pyproject.toml.bak -# Modifying generated pyproject.toml until there is an option to populate these settings. -cat << EOF >> ./bin/pyproject.toml -[build-system] -requires = ["setuptools>=61.0"] -build-backend = "setuptools.build_meta" -[tool] - [tool.setuptools] - [tool.setuptools.package-data] - pulumi_kubernetes = ["py.typed", "pulumi-plugin.json"] -EOF - # Creating an isolated venv for the bulid. python3 -m venv venv From dd8a0ffda6adfe3fe7509ae61e01b3337f4b8e31 Mon Sep 17 00:00:00 2001 From: Anton Tayanovskyy Date: Thu, 7 Sep 2023 15:37:07 -0400 Subject: [PATCH 3/4] Accept pyproject.toml changes --- sdk/python/pyproject.toml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.toml index 5da61141ee..3f42fa5eb7 100644 --- a/sdk/python/pyproject.toml +++ b/sdk/python/pyproject.toml @@ -11,3 +11,12 @@ [project.urls] Homepage = "https://pulumi.com" Repository = "https://github.com/pulumi/pulumi-kubernetes" + +[build-system] + requires = ["setuptools>=61.0"] + build-backend = "setuptools.build_meta" + +[tool] + [tool.setuptools] + [tool.setuptools.package-data] + pulumi_kubernetes = ["py.typed", "pulumi-plugin.json"] From 03e6a367f4a8ff442b8cd0962e25d13d8960eb49 Mon Sep 17 00:00:00 2001 From: Anton Tayanovskyy Date: Thu, 7 Sep 2023 18:11:39 -0400 Subject: [PATCH 4/4] make go_sdk python_sdk dotnet_sdk java_sdk nodejs_sdk --- .../v1/mutatingWebhookConfiguration.go | 37 + .../v1/mutatingWebhookConfigurationList.go | 37 + .../v1/mutatingWebhookConfigurationPatch.go | 37 + .../admissionregistration/v1/pulumiTypes.go | 373 + .../v1/validatingWebhookConfiguration.go | 37 + .../v1/validatingWebhookConfigurationList.go | 37 + .../v1/validatingWebhookConfigurationPatch.go | 37 + .../v1alpha1/pulumiTypes.go | 721 ++ .../v1alpha1/validatingAdmissionPolicy.go | 37 + .../validatingAdmissionPolicyBinding.go | 37 + .../validatingAdmissionPolicyBindingList.go | 37 + .../validatingAdmissionPolicyBindingPatch.go | 37 + .../v1alpha1/validatingAdmissionPolicyList.go | 37 + .../validatingAdmissionPolicyPatch.go | 37 + .../v1beta1/mutatingWebhookConfiguration.go | 37 + .../mutatingWebhookConfigurationList.go | 37 + .../mutatingWebhookConfigurationPatch.go | 37 + .../v1beta1/pulumiTypes.go | 1045 ++ .../v1beta1/validatingAdmissionPolicy.go | 37 + .../validatingAdmissionPolicyBinding.go | 37 + .../validatingAdmissionPolicyBindingList.go | 37 + .../validatingAdmissionPolicyBindingPatch.go | 37 + .../v1beta1/validatingAdmissionPolicyList.go | 37 + .../v1beta1/validatingAdmissionPolicyPatch.go | 37 + .../v1beta1/validatingWebhookConfiguration.go | 37 + .../validatingWebhookConfigurationList.go | 37 + .../validatingWebhookConfigurationPatch.go | 37 + .../v1/customResourceDefinition.go | 37 + .../v1/customResourceDefinitionList.go | 37 + .../v1/customResourceDefinitionPatch.go | 37 + .../apiextensions/v1/pulumiTypes.go | 841 ++ .../v1beta1/customResourceDefinition.go | 37 + .../v1beta1/customResourceDefinitionList.go | 37 + .../v1beta1/customResourceDefinitionPatch.go | 37 + .../apiextensions/v1beta1/pulumiTypes.go | 745 ++ .../apiregistration/v1/apiservice.go | 37 + .../apiregistration/v1/apiserviceList.go | 37 + .../apiregistration/v1/apiservicePatch.go | 37 + .../apiregistration/v1/pulumiTypes.go | 241 + .../apiregistration/v1beta1/apiservice.go | 37 + .../apiregistration/v1beta1/apiserviceList.go | 37 + .../v1beta1/apiservicePatch.go | 37 + .../apiregistration/v1beta1/pulumiTypes.go | 241 + .../kubernetes/apps/v1/controllerRevision.go | 37 + .../apps/v1/controllerRevisionList.go | 37 + .../apps/v1/controllerRevisionPatch.go | 37 + sdk/go/kubernetes/apps/v1/daemonSet.go | 37 + sdk/go/kubernetes/apps/v1/daemonSetList.go | 37 + sdk/go/kubernetes/apps/v1/daemonSetPatch.go | 37 + sdk/go/kubernetes/apps/v1/deployment.go | 37 + sdk/go/kubernetes/apps/v1/deploymentList.go | 37 + sdk/go/kubernetes/apps/v1/deploymentPatch.go | 37 + sdk/go/kubernetes/apps/v1/pulumiTypes.go | 1201 +++ sdk/go/kubernetes/apps/v1/replicaSet.go | 37 + sdk/go/kubernetes/apps/v1/replicaSetList.go | 37 + sdk/go/kubernetes/apps/v1/replicaSetPatch.go | 37 + sdk/go/kubernetes/apps/v1/statefulSet.go | 37 + sdk/go/kubernetes/apps/v1/statefulSetList.go | 37 + sdk/go/kubernetes/apps/v1/statefulSetPatch.go | 37 + .../apps/v1beta1/controllerRevision.go | 37 + .../apps/v1beta1/controllerRevisionList.go | 37 + .../apps/v1beta1/controllerRevisionPatch.go | 37 + sdk/go/kubernetes/apps/v1beta1/deployment.go | 37 + .../kubernetes/apps/v1beta1/deploymentList.go | 37 + .../apps/v1beta1/deploymentPatch.go | 37 + sdk/go/kubernetes/apps/v1beta1/pulumiTypes.go | 817 ++ sdk/go/kubernetes/apps/v1beta1/statefulSet.go | 37 + .../apps/v1beta1/statefulSetList.go | 37 + .../apps/v1beta1/statefulSetPatch.go | 37 + .../apps/v1beta2/controllerRevision.go | 37 + .../apps/v1beta2/controllerRevisionList.go | 37 + .../apps/v1beta2/controllerRevisionPatch.go | 37 + sdk/go/kubernetes/apps/v1beta2/daemonSet.go | 37 + .../kubernetes/apps/v1beta2/daemonSetList.go | 37 + .../kubernetes/apps/v1beta2/daemonSetPatch.go | 37 + sdk/go/kubernetes/apps/v1beta2/deployment.go | 37 + .../kubernetes/apps/v1beta2/deploymentList.go | 37 + .../apps/v1beta2/deploymentPatch.go | 37 + sdk/go/kubernetes/apps/v1beta2/pulumiTypes.go | 1225 +++ sdk/go/kubernetes/apps/v1beta2/replicaSet.go | 37 + .../kubernetes/apps/v1beta2/replicaSetList.go | 37 + .../apps/v1beta2/replicaSetPatch.go | 37 + sdk/go/kubernetes/apps/v1beta2/statefulSet.go | 37 + .../apps/v1beta2/statefulSetList.go | 37 + .../apps/v1beta2/statefulSetPatch.go | 37 + .../auditregistration/v1alpha1/auditSink.go | 37 + .../v1alpha1/auditSinkList.go | 37 + .../v1alpha1/auditSinkPatch.go | 37 + .../auditregistration/v1alpha1/pulumiTypes.go | 337 + .../authentication/v1/pulumiTypes.go | 385 + .../authentication/v1alpha1/pulumiTypes.go | 73 + .../authentication/v1beta1/pulumiTypes.go | 229 + .../authorization/v1/pulumiTypes.go | 493 + .../authorization/v1beta1/pulumiTypes.go | 493 + .../autoscaling/v1/horizontalPodAutoscaler.go | 37 + .../v1/horizontalPodAutoscalerList.go | 37 + .../v1/horizontalPodAutoscalerPatch.go | 37 + .../kubernetes/autoscaling/v1/pulumiTypes.go | 313 + .../autoscaling/v2/horizontalPodAutoscaler.go | 37 + .../v2/horizontalPodAutoscalerList.go | 37 + .../v2/horizontalPodAutoscalerPatch.go | 37 + .../kubernetes/autoscaling/v2/pulumiTypes.go | 1105 +++ .../v2beta1/horizontalPodAutoscaler.go | 37 + .../v2beta1/horizontalPodAutoscalerList.go | 37 + .../v2beta1/horizontalPodAutoscalerPatch.go | 37 + .../autoscaling/v2beta1/pulumiTypes.go | 817 ++ .../v2beta2/horizontalPodAutoscaler.go | 37 + .../v2beta2/horizontalPodAutoscalerList.go | 37 + .../v2beta2/horizontalPodAutoscalerPatch.go | 37 + .../autoscaling/v2beta2/pulumiTypes.go | 1105 +++ sdk/go/kubernetes/batch/v1/cronJob.go | 37 + sdk/go/kubernetes/batch/v1/cronJobList.go | 37 + sdk/go/kubernetes/batch/v1/cronJobPatch.go | 37 + sdk/go/kubernetes/batch/v1/job.go | 37 + sdk/go/kubernetes/batch/v1/jobList.go | 37 + sdk/go/kubernetes/batch/v1/jobPatch.go | 37 + sdk/go/kubernetes/batch/v1/pulumiTypes.go | 625 ++ sdk/go/kubernetes/batch/v1beta1/cronJob.go | 37 + .../kubernetes/batch/v1beta1/cronJobList.go | 37 + .../kubernetes/batch/v1beta1/cronJobPatch.go | 37 + .../kubernetes/batch/v1beta1/pulumiTypes.go | 193 + sdk/go/kubernetes/batch/v2alpha1/cronJob.go | 37 + .../kubernetes/batch/v2alpha1/cronJobList.go | 37 + .../kubernetes/batch/v2alpha1/cronJobPatch.go | 37 + .../kubernetes/batch/v2alpha1/pulumiTypes.go | 193 + .../v1/certificateSigningRequest.go | 37 + .../v1/certificateSigningRequestList.go | 37 + .../v1/certificateSigningRequestPatch.go | 37 + .../kubernetes/certificates/v1/pulumiTypes.go | 181 + .../v1alpha1/clusterTrustBundle.go | 37 + .../v1alpha1/clusterTrustBundleList.go | 37 + .../v1alpha1/clusterTrustBundlePatch.go | 37 + .../certificates/v1alpha1/pulumiTypes.go | 85 + .../v1beta1/certificateSigningRequest.go | 37 + .../v1beta1/certificateSigningRequestList.go | 37 + .../v1beta1/certificateSigningRequestPatch.go | 37 + .../certificates/v1beta1/pulumiTypes.go | 193 + sdk/go/kubernetes/coordination/v1/lease.go | 37 + .../kubernetes/coordination/v1/leaseList.go | 37 + .../kubernetes/coordination/v1/leasePatch.go | 37 + .../kubernetes/coordination/v1/pulumiTypes.go | 97 + .../kubernetes/coordination/v1beta1/lease.go | 37 + .../coordination/v1beta1/leaseList.go | 37 + .../coordination/v1beta1/leasePatch.go | 37 + .../coordination/v1beta1/pulumiTypes.go | 97 + sdk/go/kubernetes/core/v1/binding.go | 37 + sdk/go/kubernetes/core/v1/bindingPatch.go | 37 + sdk/go/kubernetes/core/v1/configMap.go | 37 + sdk/go/kubernetes/core/v1/configMapList.go | 37 + sdk/go/kubernetes/core/v1/configMapPatch.go | 37 + sdk/go/kubernetes/core/v1/endpoints.go | 37 + sdk/go/kubernetes/core/v1/endpointsList.go | 37 + sdk/go/kubernetes/core/v1/endpointsPatch.go | 37 + sdk/go/kubernetes/core/v1/event.go | 37 + sdk/go/kubernetes/core/v1/eventList.go | 37 + sdk/go/kubernetes/core/v1/eventPatch.go | 37 + sdk/go/kubernetes/core/v1/limitRange.go | 37 + sdk/go/kubernetes/core/v1/limitRangeList.go | 37 + sdk/go/kubernetes/core/v1/limitRangePatch.go | 37 + sdk/go/kubernetes/core/v1/namespace.go | 37 + sdk/go/kubernetes/core/v1/namespaceList.go | 37 + sdk/go/kubernetes/core/v1/namespacePatch.go | 37 + sdk/go/kubernetes/core/v1/node.go | 37 + sdk/go/kubernetes/core/v1/nodeList.go | 37 + sdk/go/kubernetes/core/v1/nodePatch.go | 37 + sdk/go/kubernetes/core/v1/persistentVolume.go | 37 + .../core/v1/persistentVolumeClaim.go | 37 + .../core/v1/persistentVolumeClaimList.go | 37 + .../core/v1/persistentVolumeClaimPatch.go | 37 + .../core/v1/persistentVolumeList.go | 37 + .../core/v1/persistentVolumePatch.go | 37 + sdk/go/kubernetes/core/v1/pod.go | 37 + sdk/go/kubernetes/core/v1/podList.go | 37 + sdk/go/kubernetes/core/v1/podPatch.go | 37 + sdk/go/kubernetes/core/v1/podTemplate.go | 37 + sdk/go/kubernetes/core/v1/podTemplateList.go | 37 + sdk/go/kubernetes/core/v1/podTemplatePatch.go | 37 + sdk/go/kubernetes/core/v1/pulumiEnums.go | 19 + sdk/go/kubernetes/core/v1/pulumiTypes.go | 8821 +++++++++++++++++ .../core/v1/replicationController.go | 37 + .../core/v1/replicationControllerList.go | 37 + .../core/v1/replicationControllerPatch.go | 37 + sdk/go/kubernetes/core/v1/resourceQuota.go | 37 + .../kubernetes/core/v1/resourceQuotaList.go | 37 + .../kubernetes/core/v1/resourceQuotaPatch.go | 37 + sdk/go/kubernetes/core/v1/secret.go | 37 + sdk/go/kubernetes/core/v1/secretList.go | 37 + sdk/go/kubernetes/core/v1/secretPatch.go | 37 + sdk/go/kubernetes/core/v1/service.go | 37 + sdk/go/kubernetes/core/v1/serviceAccount.go | 37 + .../kubernetes/core/v1/serviceAccountList.go | 37 + .../kubernetes/core/v1/serviceAccountPatch.go | 37 + sdk/go/kubernetes/core/v1/serviceList.go | 37 + sdk/go/kubernetes/core/v1/servicePatch.go | 37 + .../kubernetes/discovery/v1/endpointSlice.go | 37 + .../discovery/v1/endpointSliceList.go | 37 + .../discovery/v1/endpointSlicePatch.go | 37 + sdk/go/kubernetes/discovery/v1/pulumiTypes.go | 289 + .../discovery/v1beta1/endpointSlice.go | 37 + .../discovery/v1beta1/endpointSliceList.go | 37 + .../discovery/v1beta1/endpointSlicePatch.go | 37 + .../discovery/v1beta1/pulumiTypes.go | 193 + sdk/go/kubernetes/events/v1/event.go | 37 + sdk/go/kubernetes/events/v1/eventList.go | 37 + sdk/go/kubernetes/events/v1/eventPatch.go | 37 + sdk/go/kubernetes/events/v1/pulumiTypes.go | 97 + sdk/go/kubernetes/events/v1beta1/event.go | 37 + sdk/go/kubernetes/events/v1beta1/eventList.go | 37 + .../kubernetes/events/v1beta1/eventPatch.go | 37 + .../kubernetes/events/v1beta1/pulumiTypes.go | 97 + .../extensions/v1beta1/daemonSet.go | 37 + .../extensions/v1beta1/daemonSetList.go | 37 + .../extensions/v1beta1/daemonSetPatch.go | 37 + .../extensions/v1beta1/deployment.go | 37 + .../extensions/v1beta1/deploymentList.go | 37 + .../extensions/v1beta1/deploymentPatch.go | 37 + .../kubernetes/extensions/v1beta1/ingress.go | 37 + .../extensions/v1beta1/ingressList.go | 37 + .../extensions/v1beta1/ingressPatch.go | 37 + .../extensions/v1beta1/networkPolicy.go | 37 + .../extensions/v1beta1/networkPolicyList.go | 37 + .../extensions/v1beta1/networkPolicyPatch.go | 37 + .../extensions/v1beta1/podSecurityPolicy.go | 37 + .../v1beta1/podSecurityPolicyList.go | 37 + .../v1beta1/podSecurityPolicyPatch.go | 37 + .../extensions/v1beta1/pulumiTypes.go | 2305 +++++ .../extensions/v1beta1/replicaSet.go | 37 + .../extensions/v1beta1/replicaSetList.go | 37 + .../extensions/v1beta1/replicaSetPatch.go | 37 + .../flowcontrol/v1alpha1/flowSchema.go | 37 + .../flowcontrol/v1alpha1/flowSchemaList.go | 37 + .../flowcontrol/v1alpha1/flowSchemaPatch.go | 37 + .../v1alpha1/priorityLevelConfiguration.go | 37 + .../priorityLevelConfigurationList.go | 37 + .../priorityLevelConfigurationPatch.go | 37 + .../flowcontrol/v1alpha1/pulumiTypes.go | 961 ++ .../flowcontrol/v1beta1/flowSchema.go | 37 + .../flowcontrol/v1beta1/flowSchemaList.go | 37 + .../flowcontrol/v1beta1/flowSchemaPatch.go | 37 + .../v1beta1/priorityLevelConfiguration.go | 37 + .../v1beta1/priorityLevelConfigurationList.go | 37 + .../priorityLevelConfigurationPatch.go | 37 + .../flowcontrol/v1beta1/pulumiTypes.go | 961 ++ .../flowcontrol/v1beta2/flowSchema.go | 37 + .../flowcontrol/v1beta2/flowSchemaList.go | 37 + .../flowcontrol/v1beta2/flowSchemaPatch.go | 37 + .../v1beta2/priorityLevelConfiguration.go | 37 + .../v1beta2/priorityLevelConfigurationList.go | 37 + .../priorityLevelConfigurationPatch.go | 37 + .../flowcontrol/v1beta2/pulumiTypes.go | 1009 ++ .../flowcontrol/v1beta3/flowSchema.go | 37 + .../flowcontrol/v1beta3/flowSchemaList.go | 37 + .../flowcontrol/v1beta3/flowSchemaPatch.go | 37 + .../v1beta3/priorityLevelConfiguration.go | 37 + .../v1beta3/priorityLevelConfigurationList.go | 37 + .../priorityLevelConfigurationPatch.go | 37 + .../flowcontrol/v1beta3/pulumiTypes.go | 1009 ++ sdk/go/kubernetes/helm/v3/pulumiTypes.go | 37 + sdk/go/kubernetes/helm/v3/release.go | 37 + sdk/go/kubernetes/meta/v1/pulumiTypes.go | 841 ++ sdk/go/kubernetes/meta/v1/status.go | 37 + sdk/go/kubernetes/meta/v1/statusPatch.go | 37 + sdk/go/kubernetes/networking/v1/ingress.go | 37 + .../kubernetes/networking/v1/ingressClass.go | 37 + .../networking/v1/ingressClassList.go | 37 + .../networking/v1/ingressClassPatch.go | 37 + .../kubernetes/networking/v1/ingressList.go | 37 + .../kubernetes/networking/v1/ingressPatch.go | 37 + .../kubernetes/networking/v1/networkPolicy.go | 37 + .../networking/v1/networkPolicyList.go | 37 + .../networking/v1/networkPolicyPatch.go | 37 + .../kubernetes/networking/v1/pulumiTypes.go | 1153 +++ .../networking/v1alpha1/clusterCIDR.go | 37 + .../networking/v1alpha1/clusterCIDRList.go | 37 + .../networking/v1alpha1/clusterCIDRPatch.go | 37 + .../networking/v1alpha1/ipaddress.go | 37 + .../networking/v1alpha1/ipaddressList.go | 37 + .../networking/v1alpha1/ipaddressPatch.go | 37 + .../networking/v1alpha1/pulumiTypes.go | 241 + .../kubernetes/networking/v1beta1/ingress.go | 37 + .../networking/v1beta1/ingressClass.go | 37 + .../networking/v1beta1/ingressClassList.go | 37 + .../networking/v1beta1/ingressClassPatch.go | 37 + .../networking/v1beta1/ingressList.go | 37 + .../networking/v1beta1/ingressPatch.go | 37 + .../networking/v1beta1/pulumiTypes.go | 481 + sdk/go/kubernetes/node/v1/pulumiTypes.go | 145 + sdk/go/kubernetes/node/v1/runtimeClass.go | 37 + sdk/go/kubernetes/node/v1/runtimeClassList.go | 37 + .../kubernetes/node/v1/runtimeClassPatch.go | 37 + .../kubernetes/node/v1alpha1/pulumiTypes.go | 181 + .../kubernetes/node/v1alpha1/runtimeClass.go | 37 + .../node/v1alpha1/runtimeClassList.go | 37 + .../node/v1alpha1/runtimeClassPatch.go | 37 + sdk/go/kubernetes/node/v1beta1/pulumiTypes.go | 145 + .../kubernetes/node/v1beta1/runtimeClass.go | 37 + .../node/v1beta1/runtimeClassList.go | 37 + .../node/v1beta1/runtimeClassPatch.go | 37 + sdk/go/kubernetes/pkg/version/pulumiTypes.go | 25 + .../policy/v1/podDisruptionBudget.go | 37 + .../policy/v1/podDisruptionBudgetList.go | 37 + .../policy/v1/podDisruptionBudgetPatch.go | 37 + sdk/go/kubernetes/policy/v1/pulumiTypes.go | 169 + .../policy/v1beta1/podDisruptionBudget.go | 37 + .../policy/v1beta1/podDisruptionBudgetList.go | 37 + .../v1beta1/podDisruptionBudgetPatch.go | 37 + .../policy/v1beta1/podSecurityPolicy.go | 37 + .../policy/v1beta1/podSecurityPolicyList.go | 37 + .../policy/v1beta1/podSecurityPolicyPatch.go | 37 + .../kubernetes/policy/v1beta1/pulumiTypes.go | 793 ++ sdk/go/kubernetes/provider.go | 13 + sdk/go/kubernetes/pulumiTypes.go | 49 + sdk/go/kubernetes/rbac/v1/clusterRole.go | 37 + .../kubernetes/rbac/v1/clusterRoleBinding.go | 37 + .../rbac/v1/clusterRoleBindingList.go | 37 + .../rbac/v1/clusterRoleBindingPatch.go | 37 + sdk/go/kubernetes/rbac/v1/clusterRoleList.go | 37 + sdk/go/kubernetes/rbac/v1/clusterRolePatch.go | 37 + sdk/go/kubernetes/rbac/v1/pulumiTypes.go | 373 + sdk/go/kubernetes/rbac/v1/role.go | 37 + sdk/go/kubernetes/rbac/v1/roleBinding.go | 37 + sdk/go/kubernetes/rbac/v1/roleBindingList.go | 37 + sdk/go/kubernetes/rbac/v1/roleBindingPatch.go | 37 + sdk/go/kubernetes/rbac/v1/roleList.go | 37 + sdk/go/kubernetes/rbac/v1/rolePatch.go | 37 + .../kubernetes/rbac/v1alpha1/clusterRole.go | 37 + .../rbac/v1alpha1/clusterRoleBinding.go | 37 + .../rbac/v1alpha1/clusterRoleBindingList.go | 37 + .../rbac/v1alpha1/clusterRoleBindingPatch.go | 37 + .../rbac/v1alpha1/clusterRoleList.go | 37 + .../rbac/v1alpha1/clusterRolePatch.go | 37 + .../kubernetes/rbac/v1alpha1/pulumiTypes.go | 373 + sdk/go/kubernetes/rbac/v1alpha1/role.go | 37 + .../kubernetes/rbac/v1alpha1/roleBinding.go | 37 + .../rbac/v1alpha1/roleBindingList.go | 37 + .../rbac/v1alpha1/roleBindingPatch.go | 37 + sdk/go/kubernetes/rbac/v1alpha1/roleList.go | 37 + sdk/go/kubernetes/rbac/v1alpha1/rolePatch.go | 37 + sdk/go/kubernetes/rbac/v1beta1/clusterRole.go | 37 + .../rbac/v1beta1/clusterRoleBinding.go | 37 + .../rbac/v1beta1/clusterRoleBindingList.go | 37 + .../rbac/v1beta1/clusterRoleBindingPatch.go | 37 + .../rbac/v1beta1/clusterRoleList.go | 37 + .../rbac/v1beta1/clusterRolePatch.go | 37 + sdk/go/kubernetes/rbac/v1beta1/pulumiTypes.go | 373 + sdk/go/kubernetes/rbac/v1beta1/role.go | 37 + sdk/go/kubernetes/rbac/v1beta1/roleBinding.go | 37 + .../rbac/v1beta1/roleBindingList.go | 37 + .../rbac/v1beta1/roleBindingPatch.go | 37 + sdk/go/kubernetes/rbac/v1beta1/roleList.go | 37 + sdk/go/kubernetes/rbac/v1beta1/rolePatch.go | 37 + .../resource/v1alpha1/podScheduling.go | 37 + .../resource/v1alpha1/podSchedulingList.go | 37 + .../resource/v1alpha1/podSchedulingPatch.go | 37 + .../resource/v1alpha1/pulumiTypes.go | 637 ++ .../resource/v1alpha1/resourceClaim.go | 37 + .../resource/v1alpha1/resourceClaimList.go | 37 + .../resource/v1alpha1/resourceClaimPatch.go | 37 + .../v1alpha1/resourceClaimTemplate.go | 37 + .../v1alpha1/resourceClaimTemplateList.go | 37 + .../v1alpha1/resourceClaimTemplatePatch.go | 37 + .../resource/v1alpha1/resourceClass.go | 37 + .../resource/v1alpha1/resourceClassList.go | 37 + .../resource/v1alpha1/resourceClassPatch.go | 37 + .../resource/v1alpha2/podSchedulingContext.go | 37 + .../v1alpha2/podSchedulingContextList.go | 37 + .../v1alpha2/podSchedulingContextPatch.go | 37 + .../resource/v1alpha2/pulumiTypes.go | 685 ++ .../resource/v1alpha2/resourceClaim.go | 37 + .../resource/v1alpha2/resourceClaimList.go | 37 + .../resource/v1alpha2/resourceClaimPatch.go | 37 + .../v1alpha2/resourceClaimTemplate.go | 37 + .../v1alpha2/resourceClaimTemplateList.go | 37 + .../v1alpha2/resourceClaimTemplatePatch.go | 37 + .../resource/v1alpha2/resourceClass.go | 37 + .../resource/v1alpha2/resourceClassList.go | 37 + .../resource/v1alpha2/resourceClassPatch.go | 37 + .../kubernetes/scheduling/v1/priorityClass.go | 37 + .../scheduling/v1/priorityClassList.go | 37 + .../scheduling/v1/priorityClassPatch.go | 37 + .../kubernetes/scheduling/v1/pulumiTypes.go | 49 + .../scheduling/v1alpha1/priorityClass.go | 37 + .../scheduling/v1alpha1/priorityClassList.go | 37 + .../scheduling/v1alpha1/priorityClassPatch.go | 37 + .../scheduling/v1alpha1/pulumiTypes.go | 49 + .../scheduling/v1beta1/priorityClass.go | 37 + .../scheduling/v1beta1/priorityClassList.go | 37 + .../scheduling/v1beta1/priorityClassPatch.go | 37 + .../scheduling/v1beta1/pulumiTypes.go | 49 + .../kubernetes/settings/v1alpha1/podPreset.go | 37 + .../settings/v1alpha1/podPresetList.go | 37 + .../settings/v1alpha1/podPresetPatch.go | 37 + .../settings/v1alpha1/pulumiTypes.go | 97 + sdk/go/kubernetes/storage/v1/csidriver.go | 37 + sdk/go/kubernetes/storage/v1/csidriverList.go | 37 + .../kubernetes/storage/v1/csidriverPatch.go | 37 + sdk/go/kubernetes/storage/v1/csinode.go | 37 + sdk/go/kubernetes/storage/v1/csinodeList.go | 37 + sdk/go/kubernetes/storage/v1/csinodePatch.go | 37 + .../storage/v1/csistorageCapacity.go | 37 + .../storage/v1/csistorageCapacityList.go | 37 + .../storage/v1/csistorageCapacityPatch.go | 37 + sdk/go/kubernetes/storage/v1/pulumiTypes.go | 625 ++ sdk/go/kubernetes/storage/v1/storageClass.go | 37 + .../kubernetes/storage/v1/storageClassList.go | 37 + .../storage/v1/storageClassPatch.go | 37 + .../kubernetes/storage/v1/volumeAttachment.go | 37 + .../storage/v1/volumeAttachmentList.go | 37 + .../storage/v1/volumeAttachmentPatch.go | 37 + .../storage/v1alpha1/pulumiTypes.go | 217 + .../storage/v1alpha1/volumeAttachment.go | 37 + .../storage/v1alpha1/volumeAttachmentList.go | 37 + .../storage/v1alpha1/volumeAttachmentPatch.go | 37 + .../kubernetes/storage/v1beta1/csidriver.go | 37 + .../storage/v1beta1/csidriverList.go | 37 + .../storage/v1beta1/csidriverPatch.go | 37 + sdk/go/kubernetes/storage/v1beta1/csinode.go | 37 + .../kubernetes/storage/v1beta1/csinodeList.go | 37 + .../storage/v1beta1/csinodePatch.go | 37 + .../storage/v1beta1/csistorageCapacity.go | 37 + .../storage/v1beta1/csistorageCapacityList.go | 37 + .../v1beta1/csistorageCapacityPatch.go | 37 + .../kubernetes/storage/v1beta1/pulumiTypes.go | 625 ++ .../storage/v1beta1/storageClass.go | 37 + .../storage/v1beta1/storageClassList.go | 37 + .../storage/v1beta1/storageClassPatch.go | 37 + .../storage/v1beta1/volumeAttachment.go | 37 + .../storage/v1beta1/volumeAttachmentList.go | 37 + .../storage/v1beta1/volumeAttachmentPatch.go | 37 + sdk/nodejs/package.json | 3 +- 430 files changed, 52156 insertions(+), 2 deletions(-) diff --git a/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfiguration.go b/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfiguration.go index 3d19d508ed..a0ccca77ad 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfiguration.go +++ b/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. @@ -119,6 +120,12 @@ func (i *MutatingWebhookConfiguration) ToMutatingWebhookConfigurationOutputWithC return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationOutput) } +func (i *MutatingWebhookConfiguration) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfiguration] { + return pulumix.Output[*MutatingWebhookConfiguration]{ + OutputState: i.ToMutatingWebhookConfigurationOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationArrayInput is an input type that accepts MutatingWebhookConfigurationArray and MutatingWebhookConfigurationArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationArrayInput` via: // @@ -144,6 +151,12 @@ func (i MutatingWebhookConfigurationArray) ToMutatingWebhookConfigurationArrayOu return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationArrayOutput) } +func (i MutatingWebhookConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfiguration] { + return pulumix.Output[[]*MutatingWebhookConfiguration]{ + OutputState: i.ToMutatingWebhookConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationMapInput is an input type that accepts MutatingWebhookConfigurationMap and MutatingWebhookConfigurationMapOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationMapInput` via: // @@ -169,6 +182,12 @@ func (i MutatingWebhookConfigurationMap) ToMutatingWebhookConfigurationMapOutput return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationMapOutput) } +func (i MutatingWebhookConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfiguration] { + return pulumix.Output[map[string]*MutatingWebhookConfiguration]{ + OutputState: i.ToMutatingWebhookConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type MutatingWebhookConfigurationOutput struct{ *pulumi.OutputState } func (MutatingWebhookConfigurationOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o MutatingWebhookConfigurationOutput) ToMutatingWebhookConfigurationOutput return o } +func (o MutatingWebhookConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfiguration] { + return pulumix.Output[*MutatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *MutatingWebhookConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o MutatingWebhookConfigurationArrayOutput) ToMutatingWebhookConfigurationA return o } +func (o MutatingWebhookConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfiguration] { + return pulumix.Output[[]*MutatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MutatingWebhookConfiguration { return vs[0].([]*MutatingWebhookConfiguration)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o MutatingWebhookConfigurationMapOutput) ToMutatingWebhookConfigurationMap return o } +func (o MutatingWebhookConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfiguration] { + return pulumix.Output[map[string]*MutatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationMapOutput) MapIndex(k pulumi.StringInput) MutatingWebhookConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MutatingWebhookConfiguration { return vs[0].(map[string]*MutatingWebhookConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationList.go b/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationList.go index db5fe9f73d..1da052eb80 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationList.go +++ b/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. @@ -117,6 +118,12 @@ func (i *MutatingWebhookConfigurationList) ToMutatingWebhookConfigurationListOut return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListOutput) } +func (i *MutatingWebhookConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationList] { + return pulumix.Output[*MutatingWebhookConfigurationList]{ + OutputState: i.ToMutatingWebhookConfigurationListOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationListArrayInput is an input type that accepts MutatingWebhookConfigurationListArray and MutatingWebhookConfigurationListArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i MutatingWebhookConfigurationListArray) ToMutatingWebhookConfigurationLis return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListArrayOutput) } +func (i MutatingWebhookConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationList] { + return pulumix.Output[[]*MutatingWebhookConfigurationList]{ + OutputState: i.ToMutatingWebhookConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationListMapInput is an input type that accepts MutatingWebhookConfigurationListMap and MutatingWebhookConfigurationListMapOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i MutatingWebhookConfigurationListMap) ToMutatingWebhookConfigurationListM return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListMapOutput) } +func (i MutatingWebhookConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationList] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationList]{ + OutputState: i.ToMutatingWebhookConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type MutatingWebhookConfigurationListOutput struct{ *pulumi.OutputState } func (MutatingWebhookConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o MutatingWebhookConfigurationListOutput) ToMutatingWebhookConfigurationLi return o } +func (o MutatingWebhookConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationList] { + return pulumix.Output[*MutatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *MutatingWebhookConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o MutatingWebhookConfigurationListArrayOutput) ToMutatingWebhookConfigurat return o } +func (o MutatingWebhookConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationList] { + return pulumix.Output[[]*MutatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationListArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationList { return vs[0].([]*MutatingWebhookConfigurationList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o MutatingWebhookConfigurationListMapOutput) ToMutatingWebhookConfiguratio return o } +func (o MutatingWebhookConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationList] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationListMapOutput) MapIndex(k pulumi.StringInput) MutatingWebhookConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationList { return vs[0].(map[string]*MutatingWebhookConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationPatch.go b/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationPatch.go index 9c3687fe11..12ee5d4cec 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1/mutatingWebhookConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *MutatingWebhookConfigurationPatch) ToMutatingWebhookConfigurationPatchO return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchOutput) } +func (i *MutatingWebhookConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationPatch] { + return pulumix.Output[*MutatingWebhookConfigurationPatch]{ + OutputState: i.ToMutatingWebhookConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationPatchArrayInput is an input type that accepts MutatingWebhookConfigurationPatchArray and MutatingWebhookConfigurationPatchArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i MutatingWebhookConfigurationPatchArray) ToMutatingWebhookConfigurationPa return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchArrayOutput) } +func (i MutatingWebhookConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[[]*MutatingWebhookConfigurationPatch]{ + OutputState: i.ToMutatingWebhookConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationPatchMapInput is an input type that accepts MutatingWebhookConfigurationPatchMap and MutatingWebhookConfigurationPatchMapOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i MutatingWebhookConfigurationPatchMap) ToMutatingWebhookConfigurationPatc return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchMapOutput) } +func (i MutatingWebhookConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationPatch]{ + OutputState: i.ToMutatingWebhookConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type MutatingWebhookConfigurationPatchOutput struct{ *pulumi.OutputState } func (MutatingWebhookConfigurationPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o MutatingWebhookConfigurationPatchOutput) ToMutatingWebhookConfigurationP return o } +func (o MutatingWebhookConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationPatch] { + return pulumix.Output[*MutatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *MutatingWebhookConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o MutatingWebhookConfigurationPatchArrayOutput) ToMutatingWebhookConfigura return o } +func (o MutatingWebhookConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[[]*MutatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationPatchArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationPatch { return vs[0].([]*MutatingWebhookConfigurationPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o MutatingWebhookConfigurationPatchMapOutput) ToMutatingWebhookConfigurati return o } +func (o MutatingWebhookConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) MutatingWebhookConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationPatch { return vs[0].(map[string]*MutatingWebhookConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1/pulumiTypes.go b/sdk/go/kubernetes/admissionregistration/v1/pulumiTypes.go index 9def5da62c..0334423232 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/admissionregistration/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -73,6 +74,12 @@ func (i MatchConditionArgs) ToMatchConditionOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(MatchConditionOutput) } +func (i MatchConditionArgs) ToOutput(ctx context.Context) pulumix.Output[MatchCondition] { + return pulumix.Output[MatchCondition]{ + OutputState: i.ToMatchConditionOutputWithContext(ctx).OutputState, + } +} + // MatchConditionArrayInput is an input type that accepts MatchConditionArray and MatchConditionArrayOutput values. // You can construct a concrete instance of `MatchConditionArrayInput` via: // @@ -98,6 +105,12 @@ func (i MatchConditionArray) ToMatchConditionArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MatchConditionArrayOutput) } +func (i MatchConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]MatchCondition] { + return pulumix.Output[[]MatchCondition]{ + OutputState: i.ToMatchConditionArrayOutputWithContext(ctx).OutputState, + } +} + // MatchCondition represents a condition which must by fulfilled for a request to be sent to a webhook. type MatchConditionOutput struct{ *pulumi.OutputState } @@ -113,6 +126,12 @@ func (o MatchConditionOutput) ToMatchConditionOutputWithContext(ctx context.Cont return o } +func (o MatchConditionOutput) ToOutput(ctx context.Context) pulumix.Output[MatchCondition] { + return pulumix.Output[MatchCondition]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. Must evaluate to bool. CEL expressions have access to the contents of the AdmissionRequest and Authorizer, organized into CEL variables: // // 'object' - The object from the incoming request. The value is null for DELETE requests. 'oldObject' - The existing object. The value is null for CREATE requests. 'request' - Attributes of the admission request(/pkg/apis/admission/types.go#AdmissionRequest). 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. @@ -151,6 +170,12 @@ func (o MatchConditionArrayOutput) ToMatchConditionArrayOutputWithContext(ctx co return o } +func (o MatchConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MatchCondition] { + return pulumix.Output[[]MatchCondition]{ + OutputState: o.OutputState, + } +} + func (o MatchConditionArrayOutput) Index(i pulumi.IntInput) MatchConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchCondition { return vs[0].([]MatchCondition)[vs[1].(int)] @@ -216,6 +241,12 @@ func (i MatchConditionPatchArgs) ToMatchConditionPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(MatchConditionPatchOutput) } +func (i MatchConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MatchConditionPatch] { + return pulumix.Output[MatchConditionPatch]{ + OutputState: i.ToMatchConditionPatchOutputWithContext(ctx).OutputState, + } +} + // MatchConditionPatchArrayInput is an input type that accepts MatchConditionPatchArray and MatchConditionPatchArrayOutput values. // You can construct a concrete instance of `MatchConditionPatchArrayInput` via: // @@ -241,6 +272,12 @@ func (i MatchConditionPatchArray) ToMatchConditionPatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(MatchConditionPatchArrayOutput) } +func (i MatchConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MatchConditionPatch] { + return pulumix.Output[[]MatchConditionPatch]{ + OutputState: i.ToMatchConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MatchCondition represents a condition which must by fulfilled for a request to be sent to a webhook. type MatchConditionPatchOutput struct{ *pulumi.OutputState } @@ -256,6 +293,12 @@ func (o MatchConditionPatchOutput) ToMatchConditionPatchOutputWithContext(ctx co return o } +func (o MatchConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MatchConditionPatch] { + return pulumix.Output[MatchConditionPatch]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. Must evaluate to bool. CEL expressions have access to the contents of the AdmissionRequest and Authorizer, organized into CEL variables: // // 'object' - The object from the incoming request. The value is null for DELETE requests. 'oldObject' - The existing object. The value is null for CREATE requests. 'request' - Attributes of the admission request(/pkg/apis/admission/types.go#AdmissionRequest). 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. @@ -294,6 +337,12 @@ func (o MatchConditionPatchArrayOutput) ToMatchConditionPatchArrayOutputWithCont return o } +func (o MatchConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MatchConditionPatch] { + return pulumix.Output[[]MatchConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o MatchConditionPatchArrayOutput) Index(i pulumi.IntInput) MatchConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchConditionPatch { return vs[0].([]MatchConditionPatch)[vs[1].(int)] @@ -481,6 +530,12 @@ func (i MutatingWebhookArgs) ToMutatingWebhookOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookOutput) } +func (i MutatingWebhookArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhook] { + return pulumix.Output[MutatingWebhook]{ + OutputState: i.ToMutatingWebhookOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookArrayInput is an input type that accepts MutatingWebhookArray and MutatingWebhookArrayOutput values. // You can construct a concrete instance of `MutatingWebhookArrayInput` via: // @@ -506,6 +561,12 @@ func (i MutatingWebhookArray) ToMutatingWebhookArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookArrayOutput) } +func (i MutatingWebhookArray) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhook] { + return pulumix.Output[[]MutatingWebhook]{ + OutputState: i.ToMutatingWebhookArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhook describes an admission webhook and the resources and operations it applies to. type MutatingWebhookOutput struct{ *pulumi.OutputState } @@ -521,6 +582,12 @@ func (o MutatingWebhookOutput) ToMutatingWebhookOutputWithContext(ctx context.Co return o } +func (o MutatingWebhookOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhook] { + return pulumix.Output[MutatingWebhook]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. func (o MutatingWebhookOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v MutatingWebhook) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -646,6 +713,12 @@ func (o MutatingWebhookArrayOutput) ToMutatingWebhookArrayOutputWithContext(ctx return o } +func (o MutatingWebhookArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhook] { + return pulumix.Output[[]MutatingWebhook]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookArrayOutput) Index(i pulumi.IntInput) MutatingWebhookOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MutatingWebhook { return vs[0].([]MutatingWebhook)[vs[1].(int)] @@ -699,6 +772,12 @@ func (i MutatingWebhookConfigurationTypeArgs) ToMutatingWebhookConfigurationType return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationTypeOutput) } +func (i MutatingWebhookConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationType] { + return pulumix.Output[MutatingWebhookConfigurationType]{ + OutputState: i.ToMutatingWebhookConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationTypeArrayInput is an input type that accepts MutatingWebhookConfigurationTypeArray and MutatingWebhookConfigurationTypeArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationTypeArrayInput` via: // @@ -724,6 +803,12 @@ func (i MutatingWebhookConfigurationTypeArray) ToMutatingWebhookConfigurationTyp return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationTypeArrayOutput) } +func (i MutatingWebhookConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookConfigurationType] { + return pulumix.Output[[]MutatingWebhookConfigurationType]{ + OutputState: i.ToMutatingWebhookConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. type MutatingWebhookConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -739,6 +824,12 @@ func (o MutatingWebhookConfigurationTypeOutput) ToMutatingWebhookConfigurationTy return o } +func (o MutatingWebhookConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationType] { + return pulumix.Output[MutatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v MutatingWebhookConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -773,6 +864,12 @@ func (o MutatingWebhookConfigurationTypeArrayOutput) ToMutatingWebhookConfigurat return o } +func (o MutatingWebhookConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookConfigurationType] { + return pulumix.Output[[]MutatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationTypeArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MutatingWebhookConfigurationType { return vs[0].([]MutatingWebhookConfigurationType)[vs[1].(int)] @@ -826,6 +923,12 @@ func (i MutatingWebhookConfigurationListTypeArgs) ToMutatingWebhookConfiguration return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListTypeOutput) } +func (i MutatingWebhookConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationListType] { + return pulumix.Output[MutatingWebhookConfigurationListType]{ + OutputState: i.ToMutatingWebhookConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. type MutatingWebhookConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -841,6 +944,12 @@ func (o MutatingWebhookConfigurationListTypeOutput) ToMutatingWebhookConfigurati return o } +func (o MutatingWebhookConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationListType] { + return pulumix.Output[MutatingWebhookConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v MutatingWebhookConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -908,6 +1017,12 @@ func (i MutatingWebhookConfigurationPatchTypeArgs) ToMutatingWebhookConfiguratio return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchTypeOutput) } +func (i MutatingWebhookConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationPatchType] { + return pulumix.Output[MutatingWebhookConfigurationPatchType]{ + OutputState: i.ToMutatingWebhookConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. type MutatingWebhookConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -923,6 +1038,12 @@ func (o MutatingWebhookConfigurationPatchTypeOutput) ToMutatingWebhookConfigurat return o } +func (o MutatingWebhookConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationPatchType] { + return pulumix.Output[MutatingWebhookConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v MutatingWebhookConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1124,6 +1245,12 @@ func (i MutatingWebhookPatchArgs) ToMutatingWebhookPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookPatchOutput) } +func (i MutatingWebhookPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookPatch] { + return pulumix.Output[MutatingWebhookPatch]{ + OutputState: i.ToMutatingWebhookPatchOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookPatchArrayInput is an input type that accepts MutatingWebhookPatchArray and MutatingWebhookPatchArrayOutput values. // You can construct a concrete instance of `MutatingWebhookPatchArrayInput` via: // @@ -1149,6 +1276,12 @@ func (i MutatingWebhookPatchArray) ToMutatingWebhookPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookPatchArrayOutput) } +func (i MutatingWebhookPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookPatch] { + return pulumix.Output[[]MutatingWebhookPatch]{ + OutputState: i.ToMutatingWebhookPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhook describes an admission webhook and the resources and operations it applies to. type MutatingWebhookPatchOutput struct{ *pulumi.OutputState } @@ -1164,6 +1297,12 @@ func (o MutatingWebhookPatchOutput) ToMutatingWebhookPatchOutputWithContext(ctx return o } +func (o MutatingWebhookPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookPatch] { + return pulumix.Output[MutatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. func (o MutatingWebhookPatchOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v MutatingWebhookPatch) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -1289,6 +1428,12 @@ func (o MutatingWebhookPatchArrayOutput) ToMutatingWebhookPatchArrayOutputWithCo return o } +func (o MutatingWebhookPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookPatch] { + return pulumix.Output[[]MutatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookPatchArrayOutput) Index(i pulumi.IntInput) MutatingWebhookPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MutatingWebhookPatch { return vs[0].([]MutatingWebhookPatch)[vs[1].(int)] @@ -1358,6 +1503,12 @@ func (i RuleWithOperationsArgs) ToRuleWithOperationsOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsOutput) } +func (i RuleWithOperationsArgs) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperations] { + return pulumix.Output[RuleWithOperations]{ + OutputState: i.ToRuleWithOperationsOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperationsArrayInput is an input type that accepts RuleWithOperationsArray and RuleWithOperationsArrayOutput values. // You can construct a concrete instance of `RuleWithOperationsArrayInput` via: // @@ -1383,6 +1534,12 @@ func (i RuleWithOperationsArray) ToRuleWithOperationsArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsArrayOutput) } +func (i RuleWithOperationsArray) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperations] { + return pulumix.Output[[]RuleWithOperations]{ + OutputState: i.ToRuleWithOperationsArrayOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. type RuleWithOperationsOutput struct{ *pulumi.OutputState } @@ -1398,6 +1555,12 @@ func (o RuleWithOperationsOutput) ToRuleWithOperationsOutputWithContext(ctx cont return o } +func (o RuleWithOperationsOutput) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperations] { + return pulumix.Output[RuleWithOperations]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o RuleWithOperationsOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v RuleWithOperations) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1443,6 +1606,12 @@ func (o RuleWithOperationsArrayOutput) ToRuleWithOperationsArrayOutputWithContex return o } +func (o RuleWithOperationsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperations] { + return pulumix.Output[[]RuleWithOperations]{ + OutputState: o.OutputState, + } +} + func (o RuleWithOperationsArrayOutput) Index(i pulumi.IntInput) RuleWithOperationsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuleWithOperations { return vs[0].([]RuleWithOperations)[vs[1].(int)] @@ -1512,6 +1681,12 @@ func (i RuleWithOperationsPatchArgs) ToRuleWithOperationsPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsPatchOutput) } +func (i RuleWithOperationsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperationsPatch] { + return pulumix.Output[RuleWithOperationsPatch]{ + OutputState: i.ToRuleWithOperationsPatchOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperationsPatchArrayInput is an input type that accepts RuleWithOperationsPatchArray and RuleWithOperationsPatchArrayOutput values. // You can construct a concrete instance of `RuleWithOperationsPatchArrayInput` via: // @@ -1537,6 +1712,12 @@ func (i RuleWithOperationsPatchArray) ToRuleWithOperationsPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsPatchArrayOutput) } +func (i RuleWithOperationsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperationsPatch] { + return pulumix.Output[[]RuleWithOperationsPatch]{ + OutputState: i.ToRuleWithOperationsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. type RuleWithOperationsPatchOutput struct{ *pulumi.OutputState } @@ -1552,6 +1733,12 @@ func (o RuleWithOperationsPatchOutput) ToRuleWithOperationsPatchOutputWithContex return o } +func (o RuleWithOperationsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperationsPatch] { + return pulumix.Output[RuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o RuleWithOperationsPatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v RuleWithOperationsPatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1597,6 +1784,12 @@ func (o RuleWithOperationsPatchArrayOutput) ToRuleWithOperationsPatchArrayOutput return o } +func (o RuleWithOperationsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperationsPatch] { + return pulumix.Output[[]RuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + func (o RuleWithOperationsPatchArrayOutput) Index(i pulumi.IntInput) RuleWithOperationsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuleWithOperationsPatch { return vs[0].([]RuleWithOperationsPatch)[vs[1].(int)] @@ -1650,6 +1843,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -1691,6 +1890,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -1716,6 +1921,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the service. Required func (o ServiceReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceReference) string { return v.Name }).(pulumi.StringOutput) @@ -1750,6 +1961,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -1847,6 +2064,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -1888,6 +2111,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -1913,6 +2142,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the service. Required func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1947,6 +2182,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { @@ -2162,6 +2403,12 @@ func (i ValidatingWebhookArgs) ToValidatingWebhookOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookOutput) } +func (i ValidatingWebhookArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhook] { + return pulumix.Output[ValidatingWebhook]{ + OutputState: i.ToValidatingWebhookOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookArrayInput is an input type that accepts ValidatingWebhookArray and ValidatingWebhookArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookArrayInput` via: // @@ -2187,6 +2434,12 @@ func (i ValidatingWebhookArray) ToValidatingWebhookArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookArrayOutput) } +func (i ValidatingWebhookArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhook] { + return pulumix.Output[[]ValidatingWebhook]{ + OutputState: i.ToValidatingWebhookArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhook describes an admission webhook and the resources and operations it applies to. type ValidatingWebhookOutput struct{ *pulumi.OutputState } @@ -2202,6 +2455,12 @@ func (o ValidatingWebhookOutput) ToValidatingWebhookOutputWithContext(ctx contex return o } +func (o ValidatingWebhookOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhook] { + return pulumix.Output[ValidatingWebhook]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. func (o ValidatingWebhookOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v ValidatingWebhook) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -2316,6 +2575,12 @@ func (o ValidatingWebhookArrayOutput) ToValidatingWebhookArrayOutputWithContext( return o } +func (o ValidatingWebhookArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhook] { + return pulumix.Output[[]ValidatingWebhook]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingWebhook { return vs[0].([]ValidatingWebhook)[vs[1].(int)] @@ -2369,6 +2634,12 @@ func (i ValidatingWebhookConfigurationTypeArgs) ToValidatingWebhookConfiguration return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationTypeOutput) } +func (i ValidatingWebhookConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationType] { + return pulumix.Output[ValidatingWebhookConfigurationType]{ + OutputState: i.ToValidatingWebhookConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationTypeArrayInput is an input type that accepts ValidatingWebhookConfigurationTypeArray and ValidatingWebhookConfigurationTypeArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationTypeArrayInput` via: // @@ -2394,6 +2665,12 @@ func (i ValidatingWebhookConfigurationTypeArray) ToValidatingWebhookConfiguratio return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationTypeArrayOutput) } +func (i ValidatingWebhookConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookConfigurationType] { + return pulumix.Output[[]ValidatingWebhookConfigurationType]{ + OutputState: i.ToValidatingWebhookConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. type ValidatingWebhookConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -2409,6 +2686,12 @@ func (o ValidatingWebhookConfigurationTypeOutput) ToValidatingWebhookConfigurati return o } +func (o ValidatingWebhookConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationType] { + return pulumix.Output[ValidatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingWebhookConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2443,6 +2726,12 @@ func (o ValidatingWebhookConfigurationTypeArrayOutput) ToValidatingWebhookConfig return o } +func (o ValidatingWebhookConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookConfigurationType] { + return pulumix.Output[[]ValidatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationTypeArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingWebhookConfigurationType { return vs[0].([]ValidatingWebhookConfigurationType)[vs[1].(int)] @@ -2496,6 +2785,12 @@ func (i ValidatingWebhookConfigurationListTypeArgs) ToValidatingWebhookConfigura return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListTypeOutput) } +func (i ValidatingWebhookConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationListType] { + return pulumix.Output[ValidatingWebhookConfigurationListType]{ + OutputState: i.ToValidatingWebhookConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. type ValidatingWebhookConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -2511,6 +2806,12 @@ func (o ValidatingWebhookConfigurationListTypeOutput) ToValidatingWebhookConfigu return o } +func (o ValidatingWebhookConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationListType] { + return pulumix.Output[ValidatingWebhookConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingWebhookConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2578,6 +2879,12 @@ func (i ValidatingWebhookConfigurationPatchTypeArgs) ToValidatingWebhookConfigur return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchTypeOutput) } +func (i ValidatingWebhookConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationPatchType] { + return pulumix.Output[ValidatingWebhookConfigurationPatchType]{ + OutputState: i.ToValidatingWebhookConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. type ValidatingWebhookConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -2593,6 +2900,12 @@ func (o ValidatingWebhookConfigurationPatchTypeOutput) ToValidatingWebhookConfig return o } +func (o ValidatingWebhookConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationPatchType] { + return pulumix.Output[ValidatingWebhookConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingWebhookConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2778,6 +3091,12 @@ func (i ValidatingWebhookPatchArgs) ToValidatingWebhookPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookPatchOutput) } +func (i ValidatingWebhookPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookPatch] { + return pulumix.Output[ValidatingWebhookPatch]{ + OutputState: i.ToValidatingWebhookPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookPatchArrayInput is an input type that accepts ValidatingWebhookPatchArray and ValidatingWebhookPatchArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookPatchArrayInput` via: // @@ -2803,6 +3122,12 @@ func (i ValidatingWebhookPatchArray) ToValidatingWebhookPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookPatchArrayOutput) } +func (i ValidatingWebhookPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookPatch] { + return pulumix.Output[[]ValidatingWebhookPatch]{ + OutputState: i.ToValidatingWebhookPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhook describes an admission webhook and the resources and operations it applies to. type ValidatingWebhookPatchOutput struct{ *pulumi.OutputState } @@ -2818,6 +3143,12 @@ func (o ValidatingWebhookPatchOutput) ToValidatingWebhookPatchOutputWithContext( return o } +func (o ValidatingWebhookPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookPatch] { + return pulumix.Output[ValidatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. func (o ValidatingWebhookPatchOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v ValidatingWebhookPatch) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -2932,6 +3263,12 @@ func (o ValidatingWebhookPatchArrayOutput) ToValidatingWebhookPatchArrayOutputWi return o } +func (o ValidatingWebhookPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookPatch] { + return pulumix.Output[[]ValidatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookPatchArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingWebhookPatch { return vs[0].([]ValidatingWebhookPatch)[vs[1].(int)] @@ -3005,6 +3342,12 @@ func (i WebhookClientConfigArgs) ToWebhookClientConfigOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigOutput) } +func (i WebhookClientConfigArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook type WebhookClientConfigOutput struct{ *pulumi.OutputState } @@ -3020,6 +3363,12 @@ func (o WebhookClientConfigOutput) ToWebhookClientConfigOutputWithContext(ctx co return o } +func (o WebhookClientConfigOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + // `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfig) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -3114,6 +3463,12 @@ func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchOutput) } +func (i WebhookClientConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchPtrOutput() WebhookClientConfigPatchPtrOutput { return i.ToWebhookClientConfigPatchPtrOutputWithContext(context.Background()) } @@ -3155,6 +3510,12 @@ func (i *webhookClientConfigPatchPtrType) ToWebhookClientConfigPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchPtrOutput) } +func (i *webhookClientConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook type WebhookClientConfigPatchOutput struct{ *pulumi.OutputState } @@ -3180,6 +3541,12 @@ func (o WebhookClientConfigPatchOutput) ToWebhookClientConfigPatchPtrOutputWithC }).(WebhookClientConfigPatchPtrOutput) } +func (o WebhookClientConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + // `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfigPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -3221,6 +3588,12 @@ func (o WebhookClientConfigPatchPtrOutput) ToWebhookClientConfigPatchPtrOutputWi return o } +func (o WebhookClientConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPatchPtrOutput) Elem() WebhookClientConfigPatchOutput { return o.ApplyT(func(v *WebhookClientConfigPatch) WebhookClientConfigPatch { if v != nil { diff --git a/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfiguration.go b/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfiguration.go index 9a74aea385..7bcc7cd56f 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfiguration.go +++ b/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. @@ -119,6 +120,12 @@ func (i *ValidatingWebhookConfiguration) ToValidatingWebhookConfigurationOutputW return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationOutput) } +func (i *ValidatingWebhookConfiguration) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfiguration] { + return pulumix.Output[*ValidatingWebhookConfiguration]{ + OutputState: i.ToValidatingWebhookConfigurationOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationArrayInput is an input type that accepts ValidatingWebhookConfigurationArray and ValidatingWebhookConfigurationArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationArrayInput` via: // @@ -144,6 +151,12 @@ func (i ValidatingWebhookConfigurationArray) ToValidatingWebhookConfigurationArr return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationArrayOutput) } +func (i ValidatingWebhookConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfiguration] { + return pulumix.Output[[]*ValidatingWebhookConfiguration]{ + OutputState: i.ToValidatingWebhookConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationMapInput is an input type that accepts ValidatingWebhookConfigurationMap and ValidatingWebhookConfigurationMapOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationMapInput` via: // @@ -169,6 +182,12 @@ func (i ValidatingWebhookConfigurationMap) ToValidatingWebhookConfigurationMapOu return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationMapOutput) } +func (i ValidatingWebhookConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfiguration] { + return pulumix.Output[map[string]*ValidatingWebhookConfiguration]{ + OutputState: i.ToValidatingWebhookConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingWebhookConfigurationOutput struct{ *pulumi.OutputState } func (ValidatingWebhookConfigurationOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o ValidatingWebhookConfigurationOutput) ToValidatingWebhookConfigurationOu return o } +func (o ValidatingWebhookConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfiguration] { + return pulumix.Output[*ValidatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingWebhookConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o ValidatingWebhookConfigurationArrayOutput) ToValidatingWebhookConfigurat return o } +func (o ValidatingWebhookConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfiguration] { + return pulumix.Output[[]*ValidatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingWebhookConfiguration { return vs[0].([]*ValidatingWebhookConfiguration)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o ValidatingWebhookConfigurationMapOutput) ToValidatingWebhookConfiguratio return o } +func (o ValidatingWebhookConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfiguration] { + return pulumix.Output[map[string]*ValidatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationMapOutput) MapIndex(k pulumi.StringInput) ValidatingWebhookConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingWebhookConfiguration { return vs[0].(map[string]*ValidatingWebhookConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationList.go b/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationList.go index bb2ca1fe13..45eb6684af 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationList.go +++ b/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. @@ -117,6 +118,12 @@ func (i *ValidatingWebhookConfigurationList) ToValidatingWebhookConfigurationLis return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListOutput) } +func (i *ValidatingWebhookConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationList] { + return pulumix.Output[*ValidatingWebhookConfigurationList]{ + OutputState: i.ToValidatingWebhookConfigurationListOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationListArrayInput is an input type that accepts ValidatingWebhookConfigurationListArray and ValidatingWebhookConfigurationListArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ValidatingWebhookConfigurationListArray) ToValidatingWebhookConfiguratio return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListArrayOutput) } +func (i ValidatingWebhookConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationList] { + return pulumix.Output[[]*ValidatingWebhookConfigurationList]{ + OutputState: i.ToValidatingWebhookConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationListMapInput is an input type that accepts ValidatingWebhookConfigurationListMap and ValidatingWebhookConfigurationListMapOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i ValidatingWebhookConfigurationListMap) ToValidatingWebhookConfigurationL return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListMapOutput) } +func (i ValidatingWebhookConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationList] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationList]{ + OutputState: i.ToValidatingWebhookConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingWebhookConfigurationListOutput struct{ *pulumi.OutputState } func (ValidatingWebhookConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ValidatingWebhookConfigurationListOutput) ToValidatingWebhookConfigurati return o } +func (o ValidatingWebhookConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationList] { + return pulumix.Output[*ValidatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingWebhookConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o ValidatingWebhookConfigurationListArrayOutput) ToValidatingWebhookConfig return o } +func (o ValidatingWebhookConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationList] { + return pulumix.Output[[]*ValidatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationListArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationList { return vs[0].([]*ValidatingWebhookConfigurationList)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o ValidatingWebhookConfigurationListMapOutput) ToValidatingWebhookConfigur return o } +func (o ValidatingWebhookConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationList] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationListMapOutput) MapIndex(k pulumi.StringInput) ValidatingWebhookConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationList { return vs[0].(map[string]*ValidatingWebhookConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationPatch.go b/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationPatch.go index 4909cda839..72853407f9 100644 --- a/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1/validatingWebhookConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *ValidatingWebhookConfigurationPatch) ToValidatingWebhookConfigurationPa return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchOutput) } +func (i *ValidatingWebhookConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[*ValidatingWebhookConfigurationPatch]{ + OutputState: i.ToValidatingWebhookConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationPatchArrayInput is an input type that accepts ValidatingWebhookConfigurationPatchArray and ValidatingWebhookConfigurationPatchArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i ValidatingWebhookConfigurationPatchArray) ToValidatingWebhookConfigurati return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchArrayOutput) } +func (i ValidatingWebhookConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[[]*ValidatingWebhookConfigurationPatch]{ + OutputState: i.ToValidatingWebhookConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationPatchMapInput is an input type that accepts ValidatingWebhookConfigurationPatchMap and ValidatingWebhookConfigurationPatchMapOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i ValidatingWebhookConfigurationPatchMap) ToValidatingWebhookConfiguration return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchMapOutput) } +func (i ValidatingWebhookConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch]{ + OutputState: i.ToValidatingWebhookConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingWebhookConfigurationPatchOutput struct{ *pulumi.OutputState } func (ValidatingWebhookConfigurationPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o ValidatingWebhookConfigurationPatchOutput) ToValidatingWebhookConfigurat return o } +func (o ValidatingWebhookConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[*ValidatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ValidatingWebhookConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o ValidatingWebhookConfigurationPatchArrayOutput) ToValidatingWebhookConfi return o } +func (o ValidatingWebhookConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[[]*ValidatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationPatchArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationPatch { return vs[0].([]*ValidatingWebhookConfigurationPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o ValidatingWebhookConfigurationPatchMapOutput) ToValidatingWebhookConfigu return o } +func (o ValidatingWebhookConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) ValidatingWebhookConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationPatch { return vs[0].(map[string]*ValidatingWebhookConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/pulumiTypes.go index 53a3f5c00c..85fbfcbd4c 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -73,6 +74,12 @@ func (i AuditAnnotationArgs) ToAuditAnnotationOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationOutput) } +func (i AuditAnnotationArgs) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotation] { + return pulumix.Output[AuditAnnotation]{ + OutputState: i.ToAuditAnnotationOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotationArrayInput is an input type that accepts AuditAnnotationArray and AuditAnnotationArrayOutput values. // You can construct a concrete instance of `AuditAnnotationArrayInput` via: // @@ -98,6 +105,12 @@ func (i AuditAnnotationArray) ToAuditAnnotationArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationArrayOutput) } +func (i AuditAnnotationArray) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotation] { + return pulumix.Output[[]AuditAnnotation]{ + OutputState: i.ToAuditAnnotationArrayOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotation describes how to produce an audit annotation for an API request. type AuditAnnotationOutput struct{ *pulumi.OutputState } @@ -113,6 +126,12 @@ func (o AuditAnnotationOutput) ToAuditAnnotationOutputWithContext(ctx context.Co return o } +func (o AuditAnnotationOutput) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotation] { + return pulumix.Output[AuditAnnotation]{ + OutputState: o.OutputState, + } +} + // key specifies the audit annotation key. The audit annotation keys of a ValidatingAdmissionPolicy must be unique. The key must be a qualified name ([A-Za-z0-9][-A-Za-z0-9_.]*) no more than 63 bytes in length. // // The key is combined with the resource name of the ValidatingAdmissionPolicy to construct an audit annotation key: "{ValidatingAdmissionPolicy name}/{key}". @@ -147,6 +166,12 @@ func (o AuditAnnotationArrayOutput) ToAuditAnnotationArrayOutputWithContext(ctx return o } +func (o AuditAnnotationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotation] { + return pulumix.Output[[]AuditAnnotation]{ + OutputState: o.OutputState, + } +} + func (o AuditAnnotationArrayOutput) Index(i pulumi.IntInput) AuditAnnotationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditAnnotation { return vs[0].([]AuditAnnotation)[vs[1].(int)] @@ -212,6 +237,12 @@ func (i AuditAnnotationPatchArgs) ToAuditAnnotationPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationPatchOutput) } +func (i AuditAnnotationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotationPatch] { + return pulumix.Output[AuditAnnotationPatch]{ + OutputState: i.ToAuditAnnotationPatchOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotationPatchArrayInput is an input type that accepts AuditAnnotationPatchArray and AuditAnnotationPatchArrayOutput values. // You can construct a concrete instance of `AuditAnnotationPatchArrayInput` via: // @@ -237,6 +268,12 @@ func (i AuditAnnotationPatchArray) ToAuditAnnotationPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationPatchArrayOutput) } +func (i AuditAnnotationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotationPatch] { + return pulumix.Output[[]AuditAnnotationPatch]{ + OutputState: i.ToAuditAnnotationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotation describes how to produce an audit annotation for an API request. type AuditAnnotationPatchOutput struct{ *pulumi.OutputState } @@ -252,6 +289,12 @@ func (o AuditAnnotationPatchOutput) ToAuditAnnotationPatchOutputWithContext(ctx return o } +func (o AuditAnnotationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotationPatch] { + return pulumix.Output[AuditAnnotationPatch]{ + OutputState: o.OutputState, + } +} + // key specifies the audit annotation key. The audit annotation keys of a ValidatingAdmissionPolicy must be unique. The key must be a qualified name ([A-Za-z0-9][-A-Za-z0-9_.]*) no more than 63 bytes in length. // // The key is combined with the resource name of the ValidatingAdmissionPolicy to construct an audit annotation key: "{ValidatingAdmissionPolicy name}/{key}". @@ -286,6 +329,12 @@ func (o AuditAnnotationPatchArrayOutput) ToAuditAnnotationPatchArrayOutputWithCo return o } +func (o AuditAnnotationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotationPatch] { + return pulumix.Output[[]AuditAnnotationPatch]{ + OutputState: o.OutputState, + } +} + func (o AuditAnnotationPatchArrayOutput) Index(i pulumi.IntInput) AuditAnnotationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditAnnotationPatch { return vs[0].([]AuditAnnotationPatch)[vs[1].(int)] @@ -331,6 +380,12 @@ func (i ExpressionWarningArgs) ToExpressionWarningOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningOutput) } +func (i ExpressionWarningArgs) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarning] { + return pulumix.Output[ExpressionWarning]{ + OutputState: i.ToExpressionWarningOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarningArrayInput is an input type that accepts ExpressionWarningArray and ExpressionWarningArrayOutput values. // You can construct a concrete instance of `ExpressionWarningArrayInput` via: // @@ -356,6 +411,12 @@ func (i ExpressionWarningArray) ToExpressionWarningArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningArrayOutput) } +func (i ExpressionWarningArray) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarning] { + return pulumix.Output[[]ExpressionWarning]{ + OutputState: i.ToExpressionWarningArrayOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarning is a warning information that targets a specific expression. type ExpressionWarningOutput struct{ *pulumi.OutputState } @@ -371,6 +432,12 @@ func (o ExpressionWarningOutput) ToExpressionWarningOutputWithContext(ctx contex return o } +func (o ExpressionWarningOutput) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarning] { + return pulumix.Output[ExpressionWarning]{ + OutputState: o.OutputState, + } +} + // The path to the field that refers the expression. For example, the reference to the expression of the first item of validations is "spec.validations[0].expression" func (o ExpressionWarningOutput) FieldRef() pulumi.StringOutput { return o.ApplyT(func(v ExpressionWarning) string { return v.FieldRef }).(pulumi.StringOutput) @@ -395,6 +462,12 @@ func (o ExpressionWarningArrayOutput) ToExpressionWarningArrayOutputWithContext( return o } +func (o ExpressionWarningArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarning] { + return pulumix.Output[[]ExpressionWarning]{ + OutputState: o.OutputState, + } +} + func (o ExpressionWarningArrayOutput) Index(i pulumi.IntInput) ExpressionWarningOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ExpressionWarning { return vs[0].([]ExpressionWarning)[vs[1].(int)] @@ -440,6 +513,12 @@ func (i ExpressionWarningPatchArgs) ToExpressionWarningPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningPatchOutput) } +func (i ExpressionWarningPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarningPatch] { + return pulumix.Output[ExpressionWarningPatch]{ + OutputState: i.ToExpressionWarningPatchOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarningPatchArrayInput is an input type that accepts ExpressionWarningPatchArray and ExpressionWarningPatchArrayOutput values. // You can construct a concrete instance of `ExpressionWarningPatchArrayInput` via: // @@ -465,6 +544,12 @@ func (i ExpressionWarningPatchArray) ToExpressionWarningPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningPatchArrayOutput) } +func (i ExpressionWarningPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarningPatch] { + return pulumix.Output[[]ExpressionWarningPatch]{ + OutputState: i.ToExpressionWarningPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarning is a warning information that targets a specific expression. type ExpressionWarningPatchOutput struct{ *pulumi.OutputState } @@ -480,6 +565,12 @@ func (o ExpressionWarningPatchOutput) ToExpressionWarningPatchOutputWithContext( return o } +func (o ExpressionWarningPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarningPatch] { + return pulumix.Output[ExpressionWarningPatch]{ + OutputState: o.OutputState, + } +} + // The path to the field that refers the expression. For example, the reference to the expression of the first item of validations is "spec.validations[0].expression" func (o ExpressionWarningPatchOutput) FieldRef() pulumi.StringPtrOutput { return o.ApplyT(func(v ExpressionWarningPatch) *string { return v.FieldRef }).(pulumi.StringPtrOutput) @@ -504,6 +595,12 @@ func (o ExpressionWarningPatchArrayOutput) ToExpressionWarningPatchArrayOutputWi return o } +func (o ExpressionWarningPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarningPatch] { + return pulumix.Output[[]ExpressionWarningPatch]{ + OutputState: o.OutputState, + } +} + func (o ExpressionWarningPatchArrayOutput) Index(i pulumi.IntInput) ExpressionWarningPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ExpressionWarningPatch { return vs[0].([]ExpressionWarningPatch)[vs[1].(int)] @@ -567,6 +664,12 @@ func (i MatchConditionArgs) ToMatchConditionOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(MatchConditionOutput) } +func (i MatchConditionArgs) ToOutput(ctx context.Context) pulumix.Output[MatchCondition] { + return pulumix.Output[MatchCondition]{ + OutputState: i.ToMatchConditionOutputWithContext(ctx).OutputState, + } +} + // MatchConditionArrayInput is an input type that accepts MatchConditionArray and MatchConditionArrayOutput values. // You can construct a concrete instance of `MatchConditionArrayInput` via: // @@ -592,6 +695,12 @@ func (i MatchConditionArray) ToMatchConditionArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MatchConditionArrayOutput) } +func (i MatchConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]MatchCondition] { + return pulumix.Output[[]MatchCondition]{ + OutputState: i.ToMatchConditionArrayOutputWithContext(ctx).OutputState, + } +} + type MatchConditionOutput struct{ *pulumi.OutputState } func (MatchConditionOutput) ElementType() reflect.Type { @@ -606,6 +715,12 @@ func (o MatchConditionOutput) ToMatchConditionOutputWithContext(ctx context.Cont return o } +func (o MatchConditionOutput) ToOutput(ctx context.Context) pulumix.Output[MatchCondition] { + return pulumix.Output[MatchCondition]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. Must evaluate to bool. CEL expressions have access to the contents of the AdmissionRequest and Authorizer, organized into CEL variables: // // 'object' - The object from the incoming request. The value is null for DELETE requests. 'oldObject' - The existing object. The value is null for CREATE requests. 'request' - Attributes of the admission request(/pkg/apis/admission/types.go#AdmissionRequest). 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. @@ -644,6 +759,12 @@ func (o MatchConditionArrayOutput) ToMatchConditionArrayOutputWithContext(ctx co return o } +func (o MatchConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MatchCondition] { + return pulumix.Output[[]MatchCondition]{ + OutputState: o.OutputState, + } +} + func (o MatchConditionArrayOutput) Index(i pulumi.IntInput) MatchConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchCondition { return vs[0].([]MatchCondition)[vs[1].(int)] @@ -707,6 +828,12 @@ func (i MatchConditionPatchArgs) ToMatchConditionPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(MatchConditionPatchOutput) } +func (i MatchConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MatchConditionPatch] { + return pulumix.Output[MatchConditionPatch]{ + OutputState: i.ToMatchConditionPatchOutputWithContext(ctx).OutputState, + } +} + // MatchConditionPatchArrayInput is an input type that accepts MatchConditionPatchArray and MatchConditionPatchArrayOutput values. // You can construct a concrete instance of `MatchConditionPatchArrayInput` via: // @@ -732,6 +859,12 @@ func (i MatchConditionPatchArray) ToMatchConditionPatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(MatchConditionPatchArrayOutput) } +func (i MatchConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MatchConditionPatch] { + return pulumix.Output[[]MatchConditionPatch]{ + OutputState: i.ToMatchConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + type MatchConditionPatchOutput struct{ *pulumi.OutputState } func (MatchConditionPatchOutput) ElementType() reflect.Type { @@ -746,6 +879,12 @@ func (o MatchConditionPatchOutput) ToMatchConditionPatchOutputWithContext(ctx co return o } +func (o MatchConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MatchConditionPatch] { + return pulumix.Output[MatchConditionPatch]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. Must evaluate to bool. CEL expressions have access to the contents of the AdmissionRequest and Authorizer, organized into CEL variables: // // 'object' - The object from the incoming request. The value is null for DELETE requests. 'oldObject' - The existing object. The value is null for CREATE requests. 'request' - Attributes of the admission request(/pkg/apis/admission/types.go#AdmissionRequest). 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. @@ -784,6 +923,12 @@ func (o MatchConditionPatchArrayOutput) ToMatchConditionPatchArrayOutputWithCont return o } +func (o MatchConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MatchConditionPatch] { + return pulumix.Output[[]MatchConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o MatchConditionPatchArrayOutput) Index(i pulumi.IntInput) MatchConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchConditionPatch { return vs[0].([]MatchConditionPatch)[vs[1].(int)] @@ -913,6 +1058,12 @@ func (i MatchResourcesArgs) ToMatchResourcesOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesOutput) } +func (i MatchResourcesArgs) ToOutput(ctx context.Context) pulumix.Output[MatchResources] { + return pulumix.Output[MatchResources]{ + OutputState: i.ToMatchResourcesOutputWithContext(ctx).OutputState, + } +} + func (i MatchResourcesArgs) ToMatchResourcesPtrOutput() MatchResourcesPtrOutput { return i.ToMatchResourcesPtrOutputWithContext(context.Background()) } @@ -954,6 +1105,12 @@ func (i *matchResourcesPtrType) ToMatchResourcesPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesPtrOutput) } +func (i *matchResourcesPtrType) ToOutput(ctx context.Context) pulumix.Output[*MatchResources] { + return pulumix.Output[*MatchResources]{ + OutputState: i.ToMatchResourcesPtrOutputWithContext(ctx).OutputState, + } +} + // MatchResources decides whether to run the admission control policy on an object based on whether it meets the match criteria. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) type MatchResourcesOutput struct{ *pulumi.OutputState } @@ -979,6 +1136,12 @@ func (o MatchResourcesOutput) ToMatchResourcesPtrOutputWithContext(ctx context.C }).(MatchResourcesPtrOutput) } +func (o MatchResourcesOutput) ToOutput(ctx context.Context) pulumix.Output[MatchResources] { + return pulumix.Output[MatchResources]{ + OutputState: o.OutputState, + } +} + // ExcludeResourceRules describes what operations on what resources/subresources the ValidatingAdmissionPolicy should not care about. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) func (o MatchResourcesOutput) ExcludeResourceRules() NamedRuleWithOperationsArrayOutput { return o.ApplyT(func(v MatchResources) []NamedRuleWithOperations { return v.ExcludeResourceRules }).(NamedRuleWithOperationsArrayOutput) @@ -1054,6 +1217,12 @@ func (o MatchResourcesPtrOutput) ToMatchResourcesPtrOutputWithContext(ctx contex return o } +func (o MatchResourcesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MatchResources] { + return pulumix.Output[*MatchResources]{ + OutputState: o.OutputState, + } +} + func (o MatchResourcesPtrOutput) Elem() MatchResourcesOutput { return o.ApplyT(func(v *MatchResources) MatchResources { if v != nil { @@ -1273,6 +1442,12 @@ func (i MatchResourcesPatchArgs) ToMatchResourcesPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesPatchOutput) } +func (i MatchResourcesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MatchResourcesPatch] { + return pulumix.Output[MatchResourcesPatch]{ + OutputState: i.ToMatchResourcesPatchOutputWithContext(ctx).OutputState, + } +} + func (i MatchResourcesPatchArgs) ToMatchResourcesPatchPtrOutput() MatchResourcesPatchPtrOutput { return i.ToMatchResourcesPatchPtrOutputWithContext(context.Background()) } @@ -1314,6 +1489,12 @@ func (i *matchResourcesPatchPtrType) ToMatchResourcesPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesPatchPtrOutput) } +func (i *matchResourcesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MatchResourcesPatch] { + return pulumix.Output[*MatchResourcesPatch]{ + OutputState: i.ToMatchResourcesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MatchResources decides whether to run the admission control policy on an object based on whether it meets the match criteria. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) type MatchResourcesPatchOutput struct{ *pulumi.OutputState } @@ -1339,6 +1520,12 @@ func (o MatchResourcesPatchOutput) ToMatchResourcesPatchPtrOutputWithContext(ctx }).(MatchResourcesPatchPtrOutput) } +func (o MatchResourcesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MatchResourcesPatch] { + return pulumix.Output[MatchResourcesPatch]{ + OutputState: o.OutputState, + } +} + // ExcludeResourceRules describes what operations on what resources/subresources the ValidatingAdmissionPolicy should not care about. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) func (o MatchResourcesPatchOutput) ExcludeResourceRules() NamedRuleWithOperationsPatchArrayOutput { return o.ApplyT(func(v MatchResourcesPatch) []NamedRuleWithOperationsPatch { return v.ExcludeResourceRules }).(NamedRuleWithOperationsPatchArrayOutput) @@ -1414,6 +1601,12 @@ func (o MatchResourcesPatchPtrOutput) ToMatchResourcesPatchPtrOutputWithContext( return o } +func (o MatchResourcesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MatchResourcesPatch] { + return pulumix.Output[*MatchResourcesPatch]{ + OutputState: o.OutputState, + } +} + func (o MatchResourcesPatchPtrOutput) Elem() MatchResourcesPatchOutput { return o.ApplyT(func(v *MatchResourcesPatch) MatchResourcesPatch { if v != nil { @@ -1577,6 +1770,12 @@ func (i NamedRuleWithOperationsArgs) ToNamedRuleWithOperationsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsOutput) } +func (i NamedRuleWithOperationsArgs) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperations] { + return pulumix.Output[NamedRuleWithOperations]{ + OutputState: i.ToNamedRuleWithOperationsOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperationsArrayInput is an input type that accepts NamedRuleWithOperationsArray and NamedRuleWithOperationsArrayOutput values. // You can construct a concrete instance of `NamedRuleWithOperationsArrayInput` via: // @@ -1602,6 +1801,12 @@ func (i NamedRuleWithOperationsArray) ToNamedRuleWithOperationsArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsArrayOutput) } +func (i NamedRuleWithOperationsArray) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperations] { + return pulumix.Output[[]NamedRuleWithOperations]{ + OutputState: i.ToNamedRuleWithOperationsArrayOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperations is a tuple of Operations and Resources with ResourceNames. type NamedRuleWithOperationsOutput struct{ *pulumi.OutputState } @@ -1617,6 +1822,12 @@ func (o NamedRuleWithOperationsOutput) ToNamedRuleWithOperationsOutputWithContex return o } +func (o NamedRuleWithOperationsOutput) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperations] { + return pulumix.Output[NamedRuleWithOperations]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o NamedRuleWithOperationsOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v NamedRuleWithOperations) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1667,6 +1878,12 @@ func (o NamedRuleWithOperationsArrayOutput) ToNamedRuleWithOperationsArrayOutput return o } +func (o NamedRuleWithOperationsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperations] { + return pulumix.Output[[]NamedRuleWithOperations]{ + OutputState: o.OutputState, + } +} + func (o NamedRuleWithOperationsArrayOutput) Index(i pulumi.IntInput) NamedRuleWithOperationsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamedRuleWithOperations { return vs[0].([]NamedRuleWithOperations)[vs[1].(int)] @@ -1740,6 +1957,12 @@ func (i NamedRuleWithOperationsPatchArgs) ToNamedRuleWithOperationsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsPatchOutput) } +func (i NamedRuleWithOperationsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperationsPatch] { + return pulumix.Output[NamedRuleWithOperationsPatch]{ + OutputState: i.ToNamedRuleWithOperationsPatchOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperationsPatchArrayInput is an input type that accepts NamedRuleWithOperationsPatchArray and NamedRuleWithOperationsPatchArrayOutput values. // You can construct a concrete instance of `NamedRuleWithOperationsPatchArrayInput` via: // @@ -1765,6 +1988,12 @@ func (i NamedRuleWithOperationsPatchArray) ToNamedRuleWithOperationsPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsPatchArrayOutput) } +func (i NamedRuleWithOperationsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperationsPatch] { + return pulumix.Output[[]NamedRuleWithOperationsPatch]{ + OutputState: i.ToNamedRuleWithOperationsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperations is a tuple of Operations and Resources with ResourceNames. type NamedRuleWithOperationsPatchOutput struct{ *pulumi.OutputState } @@ -1780,6 +2009,12 @@ func (o NamedRuleWithOperationsPatchOutput) ToNamedRuleWithOperationsPatchOutput return o } +func (o NamedRuleWithOperationsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperationsPatch] { + return pulumix.Output[NamedRuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o NamedRuleWithOperationsPatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v NamedRuleWithOperationsPatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1830,6 +2065,12 @@ func (o NamedRuleWithOperationsPatchArrayOutput) ToNamedRuleWithOperationsPatchA return o } +func (o NamedRuleWithOperationsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperationsPatch] { + return pulumix.Output[[]NamedRuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + func (o NamedRuleWithOperationsPatchArrayOutput) Index(i pulumi.IntInput) NamedRuleWithOperationsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamedRuleWithOperationsPatch { return vs[0].([]NamedRuleWithOperationsPatch)[vs[1].(int)] @@ -1875,6 +2116,12 @@ func (i ParamKindArgs) ToParamKindOutputWithContext(ctx context.Context) ParamKi return pulumi.ToOutputWithContext(ctx, i).(ParamKindOutput) } +func (i ParamKindArgs) ToOutput(ctx context.Context) pulumix.Output[ParamKind] { + return pulumix.Output[ParamKind]{ + OutputState: i.ToParamKindOutputWithContext(ctx).OutputState, + } +} + func (i ParamKindArgs) ToParamKindPtrOutput() ParamKindPtrOutput { return i.ToParamKindPtrOutputWithContext(context.Background()) } @@ -1916,6 +2163,12 @@ func (i *paramKindPtrType) ToParamKindPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ParamKindPtrOutput) } +func (i *paramKindPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamKind] { + return pulumix.Output[*ParamKind]{ + OutputState: i.ToParamKindPtrOutputWithContext(ctx).OutputState, + } +} + // ParamKind is a tuple of Group Kind and Version. type ParamKindOutput struct{ *pulumi.OutputState } @@ -1941,6 +2194,12 @@ func (o ParamKindOutput) ToParamKindPtrOutputWithContext(ctx context.Context) Pa }).(ParamKindPtrOutput) } +func (o ParamKindOutput) ToOutput(ctx context.Context) pulumix.Output[ParamKind] { + return pulumix.Output[ParamKind]{ + OutputState: o.OutputState, + } +} + // APIVersion is the API group version the resources belong to. In format of "group/version". Required. func (o ParamKindOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ParamKind) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1965,6 +2224,12 @@ func (o ParamKindPtrOutput) ToParamKindPtrOutputWithContext(ctx context.Context) return o } +func (o ParamKindPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamKind] { + return pulumix.Output[*ParamKind]{ + OutputState: o.OutputState, + } +} + func (o ParamKindPtrOutput) Elem() ParamKindOutput { return o.ApplyT(func(v *ParamKind) ParamKind { if v != nil { @@ -2034,6 +2299,12 @@ func (i ParamKindPatchArgs) ToParamKindPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ParamKindPatchOutput) } +func (i ParamKindPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ParamKindPatch] { + return pulumix.Output[ParamKindPatch]{ + OutputState: i.ToParamKindPatchOutputWithContext(ctx).OutputState, + } +} + func (i ParamKindPatchArgs) ToParamKindPatchPtrOutput() ParamKindPatchPtrOutput { return i.ToParamKindPatchPtrOutputWithContext(context.Background()) } @@ -2075,6 +2346,12 @@ func (i *paramKindPatchPtrType) ToParamKindPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ParamKindPatchPtrOutput) } +func (i *paramKindPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamKindPatch] { + return pulumix.Output[*ParamKindPatch]{ + OutputState: i.ToParamKindPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ParamKind is a tuple of Group Kind and Version. type ParamKindPatchOutput struct{ *pulumi.OutputState } @@ -2100,6 +2377,12 @@ func (o ParamKindPatchOutput) ToParamKindPatchPtrOutputWithContext(ctx context.C }).(ParamKindPatchPtrOutput) } +func (o ParamKindPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ParamKindPatch] { + return pulumix.Output[ParamKindPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion is the API group version the resources belong to. In format of "group/version". Required. func (o ParamKindPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ParamKindPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2124,6 +2407,12 @@ func (o ParamKindPatchPtrOutput) ToParamKindPatchPtrOutputWithContext(ctx contex return o } +func (o ParamKindPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamKindPatch] { + return pulumix.Output[*ParamKindPatch]{ + OutputState: o.OutputState, + } +} + func (o ParamKindPatchPtrOutput) Elem() ParamKindPatchOutput { return o.ApplyT(func(v *ParamKindPatch) ParamKindPatch { if v != nil { @@ -2229,6 +2518,12 @@ func (i ParamRefArgs) ToParamRefOutputWithContext(ctx context.Context) ParamRefO return pulumi.ToOutputWithContext(ctx, i).(ParamRefOutput) } +func (i ParamRefArgs) ToOutput(ctx context.Context) pulumix.Output[ParamRef] { + return pulumix.Output[ParamRef]{ + OutputState: i.ToParamRefOutputWithContext(ctx).OutputState, + } +} + func (i ParamRefArgs) ToParamRefPtrOutput() ParamRefPtrOutput { return i.ToParamRefPtrOutputWithContext(context.Background()) } @@ -2270,6 +2565,12 @@ func (i *paramRefPtrType) ToParamRefPtrOutputWithContext(ctx context.Context) Pa return pulumi.ToOutputWithContext(ctx, i).(ParamRefPtrOutput) } +func (i *paramRefPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamRef] { + return pulumix.Output[*ParamRef]{ + OutputState: i.ToParamRefPtrOutputWithContext(ctx).OutputState, + } +} + // ParamRef describes how to locate the params to be used as input to expressions of rules applied by a policy binding. type ParamRefOutput struct{ *pulumi.OutputState } @@ -2295,6 +2596,12 @@ func (o ParamRefOutput) ToParamRefPtrOutputWithContext(ctx context.Context) Para }).(ParamRefPtrOutput) } +func (o ParamRefOutput) ToOutput(ctx context.Context) pulumix.Output[ParamRef] { + return pulumix.Output[ParamRef]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the resource being referenced. // // `name` and `selector` are mutually exclusive properties. If one is set, the other must be unset. @@ -2343,6 +2650,12 @@ func (o ParamRefPtrOutput) ToParamRefPtrOutputWithContext(ctx context.Context) P return o } +func (o ParamRefPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamRef] { + return pulumix.Output[*ParamRef]{ + OutputState: o.OutputState, + } +} + func (o ParamRefPtrOutput) Elem() ParamRefOutput { return o.ApplyT(func(v *ParamRef) ParamRef { if v != nil { @@ -2482,6 +2795,12 @@ func (i ParamRefPatchArgs) ToParamRefPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ParamRefPatchOutput) } +func (i ParamRefPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ParamRefPatch] { + return pulumix.Output[ParamRefPatch]{ + OutputState: i.ToParamRefPatchOutputWithContext(ctx).OutputState, + } +} + func (i ParamRefPatchArgs) ToParamRefPatchPtrOutput() ParamRefPatchPtrOutput { return i.ToParamRefPatchPtrOutputWithContext(context.Background()) } @@ -2523,6 +2842,12 @@ func (i *paramRefPatchPtrType) ToParamRefPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ParamRefPatchPtrOutput) } +func (i *paramRefPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamRefPatch] { + return pulumix.Output[*ParamRefPatch]{ + OutputState: i.ToParamRefPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ParamRef describes how to locate the params to be used as input to expressions of rules applied by a policy binding. type ParamRefPatchOutput struct{ *pulumi.OutputState } @@ -2548,6 +2873,12 @@ func (o ParamRefPatchOutput) ToParamRefPatchPtrOutputWithContext(ctx context.Con }).(ParamRefPatchPtrOutput) } +func (o ParamRefPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ParamRefPatch] { + return pulumix.Output[ParamRefPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the resource being referenced. // // `name` and `selector` are mutually exclusive properties. If one is set, the other must be unset. @@ -2596,6 +2927,12 @@ func (o ParamRefPatchPtrOutput) ToParamRefPatchPtrOutputWithContext(ctx context. return o } +func (o ParamRefPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamRefPatch] { + return pulumix.Output[*ParamRefPatch]{ + OutputState: o.OutputState, + } +} + func (o ParamRefPatchPtrOutput) Elem() ParamRefPatchOutput { return o.ApplyT(func(v *ParamRefPatch) ParamRefPatch { if v != nil { @@ -2695,6 +3032,12 @@ func (i TypeCheckingArgs) ToTypeCheckingOutputWithContext(ctx context.Context) T return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingOutput) } +func (i TypeCheckingArgs) ToOutput(ctx context.Context) pulumix.Output[TypeChecking] { + return pulumix.Output[TypeChecking]{ + OutputState: i.ToTypeCheckingOutputWithContext(ctx).OutputState, + } +} + func (i TypeCheckingArgs) ToTypeCheckingPtrOutput() TypeCheckingPtrOutput { return i.ToTypeCheckingPtrOutputWithContext(context.Background()) } @@ -2736,6 +3079,12 @@ func (i *typeCheckingPtrType) ToTypeCheckingPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingPtrOutput) } +func (i *typeCheckingPtrType) ToOutput(ctx context.Context) pulumix.Output[*TypeChecking] { + return pulumix.Output[*TypeChecking]{ + OutputState: i.ToTypeCheckingPtrOutputWithContext(ctx).OutputState, + } +} + // TypeChecking contains results of type checking the expressions in the ValidatingAdmissionPolicy type TypeCheckingOutput struct{ *pulumi.OutputState } @@ -2761,6 +3110,12 @@ func (o TypeCheckingOutput) ToTypeCheckingPtrOutputWithContext(ctx context.Conte }).(TypeCheckingPtrOutput) } +func (o TypeCheckingOutput) ToOutput(ctx context.Context) pulumix.Output[TypeChecking] { + return pulumix.Output[TypeChecking]{ + OutputState: o.OutputState, + } +} + // The type checking warnings for each expression. func (o TypeCheckingOutput) ExpressionWarnings() ExpressionWarningArrayOutput { return o.ApplyT(func(v TypeChecking) []ExpressionWarning { return v.ExpressionWarnings }).(ExpressionWarningArrayOutput) @@ -2780,6 +3135,12 @@ func (o TypeCheckingPtrOutput) ToTypeCheckingPtrOutputWithContext(ctx context.Co return o } +func (o TypeCheckingPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypeChecking] { + return pulumix.Output[*TypeChecking]{ + OutputState: o.OutputState, + } +} + func (o TypeCheckingPtrOutput) Elem() TypeCheckingOutput { return o.ApplyT(func(v *TypeChecking) TypeChecking { if v != nil { @@ -2835,6 +3196,12 @@ func (i TypeCheckingPatchArgs) ToTypeCheckingPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingPatchOutput) } +func (i TypeCheckingPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TypeCheckingPatch] { + return pulumix.Output[TypeCheckingPatch]{ + OutputState: i.ToTypeCheckingPatchOutputWithContext(ctx).OutputState, + } +} + func (i TypeCheckingPatchArgs) ToTypeCheckingPatchPtrOutput() TypeCheckingPatchPtrOutput { return i.ToTypeCheckingPatchPtrOutputWithContext(context.Background()) } @@ -2876,6 +3243,12 @@ func (i *typeCheckingPatchPtrType) ToTypeCheckingPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingPatchPtrOutput) } +func (i *typeCheckingPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TypeCheckingPatch] { + return pulumix.Output[*TypeCheckingPatch]{ + OutputState: i.ToTypeCheckingPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TypeChecking contains results of type checking the expressions in the ValidatingAdmissionPolicy type TypeCheckingPatchOutput struct{ *pulumi.OutputState } @@ -2901,6 +3274,12 @@ func (o TypeCheckingPatchOutput) ToTypeCheckingPatchPtrOutputWithContext(ctx con }).(TypeCheckingPatchPtrOutput) } +func (o TypeCheckingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TypeCheckingPatch] { + return pulumix.Output[TypeCheckingPatch]{ + OutputState: o.OutputState, + } +} + // The type checking warnings for each expression. func (o TypeCheckingPatchOutput) ExpressionWarnings() ExpressionWarningPatchArrayOutput { return o.ApplyT(func(v TypeCheckingPatch) []ExpressionWarningPatch { return v.ExpressionWarnings }).(ExpressionWarningPatchArrayOutput) @@ -2920,6 +3299,12 @@ func (o TypeCheckingPatchPtrOutput) ToTypeCheckingPatchPtrOutputWithContext(ctx return o } +func (o TypeCheckingPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypeCheckingPatch] { + return pulumix.Output[*TypeCheckingPatch]{ + OutputState: o.OutputState, + } +} + func (o TypeCheckingPatchPtrOutput) Elem() TypeCheckingPatchOutput { return o.ApplyT(func(v *TypeCheckingPatch) TypeCheckingPatch { if v != nil { @@ -2991,6 +3376,12 @@ func (i ValidatingAdmissionPolicyTypeArgs) ToValidatingAdmissionPolicyTypeOutput return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyTypeOutput) } +func (i ValidatingAdmissionPolicyTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyType] { + return pulumix.Output[ValidatingAdmissionPolicyType]{ + OutputState: i.ToValidatingAdmissionPolicyTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyTypeArrayInput is an input type that accepts ValidatingAdmissionPolicyTypeArray and ValidatingAdmissionPolicyTypeArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyTypeArrayInput` via: // @@ -3016,6 +3407,12 @@ func (i ValidatingAdmissionPolicyTypeArray) ToValidatingAdmissionPolicyTypeArray return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyTypeArrayOutput) } +func (i ValidatingAdmissionPolicyTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyType] { + return pulumix.Output[[]ValidatingAdmissionPolicyType]{ + OutputState: i.ToValidatingAdmissionPolicyTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicy describes the definition of an admission validation policy that accepts or rejects an object without changing it. type ValidatingAdmissionPolicyTypeOutput struct{ *pulumi.OutputState } @@ -3031,6 +3428,12 @@ func (o ValidatingAdmissionPolicyTypeOutput) ToValidatingAdmissionPolicyTypeOutp return o } +func (o ValidatingAdmissionPolicyTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyType] { + return pulumix.Output[ValidatingAdmissionPolicyType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3070,6 +3473,12 @@ func (o ValidatingAdmissionPolicyTypeArrayOutput) ToValidatingAdmissionPolicyTyp return o } +func (o ValidatingAdmissionPolicyTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyType] { + return pulumix.Output[[]ValidatingAdmissionPolicyType]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyTypeArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingAdmissionPolicyType { return vs[0].([]ValidatingAdmissionPolicyType)[vs[1].(int)] @@ -3131,6 +3540,12 @@ func (i ValidatingAdmissionPolicyBindingTypeArgs) ToValidatingAdmissionPolicyBin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingTypeOutput) } +func (i ValidatingAdmissionPolicyBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingTypeArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingTypeArray and ValidatingAdmissionPolicyBindingTypeArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingTypeArrayInput` via: // @@ -3156,6 +3571,12 @@ func (i ValidatingAdmissionPolicyBindingTypeArray) ToValidatingAdmissionPolicyBi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingTypeArrayOutput) } +func (i ValidatingAdmissionPolicyBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[[]ValidatingAdmissionPolicyBindingType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBinding binds the ValidatingAdmissionPolicy with paramerized resources. ValidatingAdmissionPolicyBinding and parameter CRDs together define how cluster administrators configure policies for clusters. // // For a given admission request, each binding will cause its policy to be evaluated N times, where N is 1 for policies/bindings that don't use params, otherwise N is the number of parameters selected by the binding. @@ -3175,6 +3596,12 @@ func (o ValidatingAdmissionPolicyBindingTypeOutput) ToValidatingAdmissionPolicyB return o } +func (o ValidatingAdmissionPolicyBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3209,6 +3636,12 @@ func (o ValidatingAdmissionPolicyBindingTypeArrayOutput) ToValidatingAdmissionPo return o } +func (o ValidatingAdmissionPolicyBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[[]ValidatingAdmissionPolicyBindingType]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingTypeArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingAdmissionPolicyBindingType { return vs[0].([]ValidatingAdmissionPolicyBindingType)[vs[1].(int)] @@ -3262,6 +3695,12 @@ func (i ValidatingAdmissionPolicyBindingListTypeArgs) ToValidatingAdmissionPolic return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListTypeOutput) } +func (i ValidatingAdmissionPolicyBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingListType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingListType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingList is a list of ValidatingAdmissionPolicyBinding. type ValidatingAdmissionPolicyBindingListTypeOutput struct{ *pulumi.OutputState } @@ -3277,6 +3716,12 @@ func (o ValidatingAdmissionPolicyBindingListTypeOutput) ToValidatingAdmissionPol return o } +func (o ValidatingAdmissionPolicyBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingListType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3354,6 +3799,12 @@ func (i ValidatingAdmissionPolicyBindingPatchTypeArgs) ToValidatingAdmissionPoli return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchTypeOutput) } +func (i ValidatingAdmissionPolicyBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingPatchType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBinding binds the ValidatingAdmissionPolicy with paramerized resources. ValidatingAdmissionPolicyBinding and parameter CRDs together define how cluster administrators configure policies for clusters. // // For a given admission request, each binding will cause its policy to be evaluated N times, where N is 1 for policies/bindings that don't use params, otherwise N is the number of parameters selected by the binding. @@ -3373,6 +3824,12 @@ func (o ValidatingAdmissionPolicyBindingPatchTypeOutput) ToValidatingAdmissionPo return o } +func (o ValidatingAdmissionPolicyBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3478,6 +3935,12 @@ func (i ValidatingAdmissionPolicyBindingSpecArgs) ToValidatingAdmissionPolicyBin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecOutput) } +func (i ValidatingAdmissionPolicyBindingSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpec]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyBindingSpecArgs) ToValidatingAdmissionPolicyBindingSpecPtrOutput() ValidatingAdmissionPolicyBindingSpecPtrOutput { return i.ToValidatingAdmissionPolicyBindingSpecPtrOutputWithContext(context.Background()) } @@ -3519,6 +3982,12 @@ func (i *validatingAdmissionPolicyBindingSpecPtrType) ToValidatingAdmissionPolic return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecPtrOutput) } +func (i *validatingAdmissionPolicyBindingSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpec]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingSpec is the specification of the ValidatingAdmissionPolicyBinding. type ValidatingAdmissionPolicyBindingSpecOutput struct{ *pulumi.OutputState } @@ -3544,6 +4013,12 @@ func (o ValidatingAdmissionPolicyBindingSpecOutput) ToValidatingAdmissionPolicyB }).(ValidatingAdmissionPolicyBindingSpecPtrOutput) } +func (o ValidatingAdmissionPolicyBindingSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpec]{ + OutputState: o.OutputState, + } +} + // MatchResources declares what resources match this binding and will be validated by it. Note that this is intersected with the policy's matchConstraints, so only requests that are matched by the policy can be selected by this. If this is unset, all resources matched by the policy are validated by this binding When resourceRules is unset, it does not constrain resource matching. If a resource is matched by the other fields of this object, it will be validated. Note that this is differs from ValidatingAdmissionPolicy matchConstraints, where resourceRules are required. func (o ValidatingAdmissionPolicyBindingSpecOutput) MatchResources() MatchResourcesPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingSpec) *MatchResources { return v.MatchResources }).(MatchResourcesPtrOutput) @@ -3596,6 +4071,12 @@ func (o ValidatingAdmissionPolicyBindingSpecPtrOutput) ToValidatingAdmissionPoli return o } +func (o ValidatingAdmissionPolicyBindingSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpec]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingSpecPtrOutput) Elem() ValidatingAdmissionPolicyBindingSpecOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingSpec) ValidatingAdmissionPolicyBindingSpec { if v != nil { @@ -3747,6 +4228,12 @@ func (i ValidatingAdmissionPolicyBindingSpecPatchArgs) ToValidatingAdmissionPoli return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecPatchOutput) } +func (i ValidatingAdmissionPolicyBindingSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyBindingSpecPatchArgs) ToValidatingAdmissionPolicyBindingSpecPatchPtrOutput() ValidatingAdmissionPolicyBindingSpecPatchPtrOutput { return i.ToValidatingAdmissionPolicyBindingSpecPatchPtrOutputWithContext(context.Background()) } @@ -3788,6 +4275,12 @@ func (i *validatingAdmissionPolicyBindingSpecPatchPtrType) ToValidatingAdmission return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) } +func (i *validatingAdmissionPolicyBindingSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingSpec is the specification of the ValidatingAdmissionPolicyBinding. type ValidatingAdmissionPolicyBindingSpecPatchOutput struct{ *pulumi.OutputState } @@ -3813,6 +4306,12 @@ func (o ValidatingAdmissionPolicyBindingSpecPatchOutput) ToValidatingAdmissionPo }).(ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) } +func (o ValidatingAdmissionPolicyBindingSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: o.OutputState, + } +} + // MatchResources declares what resources match this binding and will be validated by it. Note that this is intersected with the policy's matchConstraints, so only requests that are matched by the policy can be selected by this. If this is unset, all resources matched by the policy are validated by this binding When resourceRules is unset, it does not constrain resource matching. If a resource is matched by the other fields of this object, it will be validated. Note that this is differs from ValidatingAdmissionPolicy matchConstraints, where resourceRules are required. func (o ValidatingAdmissionPolicyBindingSpecPatchOutput) MatchResources() MatchResourcesPatchPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingSpecPatch) *MatchResourcesPatch { return v.MatchResources }).(MatchResourcesPatchPtrOutput) @@ -3865,6 +4364,12 @@ func (o ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) ToValidatingAdmissio return o } +func (o ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) Elem() ValidatingAdmissionPolicyBindingSpecPatchOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingSpecPatch) ValidatingAdmissionPolicyBindingSpecPatch { if v != nil { @@ -3980,6 +4485,12 @@ func (i ValidatingAdmissionPolicyListTypeArgs) ToValidatingAdmissionPolicyListTy return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListTypeOutput) } +func (i ValidatingAdmissionPolicyListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyListType] { + return pulumix.Output[ValidatingAdmissionPolicyListType]{ + OutputState: i.ToValidatingAdmissionPolicyListTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyList is a list of ValidatingAdmissionPolicy. type ValidatingAdmissionPolicyListTypeOutput struct{ *pulumi.OutputState } @@ -3995,6 +4506,12 @@ func (o ValidatingAdmissionPolicyListTypeOutput) ToValidatingAdmissionPolicyList return o } +func (o ValidatingAdmissionPolicyListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyListType] { + return pulumix.Output[ValidatingAdmissionPolicyListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4066,6 +4583,12 @@ func (i ValidatingAdmissionPolicyPatchTypeArgs) ToValidatingAdmissionPolicyPatch return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchTypeOutput) } +func (i ValidatingAdmissionPolicyPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyPatchType]{ + OutputState: i.ToValidatingAdmissionPolicyPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicy describes the definition of an admission validation policy that accepts or rejects an object without changing it. type ValidatingAdmissionPolicyPatchTypeOutput struct{ *pulumi.OutputState } @@ -4081,6 +4604,12 @@ func (o ValidatingAdmissionPolicyPatchTypeOutput) ToValidatingAdmissionPolicyPat return o } +func (o ValidatingAdmissionPolicyPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4203,6 +4732,12 @@ func (i ValidatingAdmissionPolicySpecArgs) ToValidatingAdmissionPolicySpecOutput return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecOutput) } +func (i ValidatingAdmissionPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpec] { + return pulumix.Output[ValidatingAdmissionPolicySpec]{ + OutputState: i.ToValidatingAdmissionPolicySpecOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicySpecArgs) ToValidatingAdmissionPolicySpecPtrOutput() ValidatingAdmissionPolicySpecPtrOutput { return i.ToValidatingAdmissionPolicySpecPtrOutputWithContext(context.Background()) } @@ -4244,6 +4779,12 @@ func (i *validatingAdmissionPolicySpecPtrType) ToValidatingAdmissionPolicySpecPt return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecPtrOutput) } +func (i *validatingAdmissionPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpec] { + return pulumix.Output[*ValidatingAdmissionPolicySpec]{ + OutputState: i.ToValidatingAdmissionPolicySpecPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicySpec is the specification of the desired behavior of the AdmissionPolicy. type ValidatingAdmissionPolicySpecOutput struct{ *pulumi.OutputState } @@ -4269,6 +4810,12 @@ func (o ValidatingAdmissionPolicySpecOutput) ToValidatingAdmissionPolicySpecPtrO }).(ValidatingAdmissionPolicySpecPtrOutput) } +func (o ValidatingAdmissionPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpec] { + return pulumix.Output[ValidatingAdmissionPolicySpec]{ + OutputState: o.OutputState, + } +} + // auditAnnotations contains CEL expressions which are used to produce audit annotations for the audit event of the API request. validations and auditAnnotations may not both be empty; a least one of validations or auditAnnotations is required. func (o ValidatingAdmissionPolicySpecOutput) AuditAnnotations() AuditAnnotationArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicySpec) []AuditAnnotation { return v.AuditAnnotations }).(AuditAnnotationArrayOutput) @@ -4337,6 +4884,12 @@ func (o ValidatingAdmissionPolicySpecPtrOutput) ToValidatingAdmissionPolicySpecP return o } +func (o ValidatingAdmissionPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpec] { + return pulumix.Output[*ValidatingAdmissionPolicySpec]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicySpecPtrOutput) Elem() ValidatingAdmissionPolicySpecOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicySpec) ValidatingAdmissionPolicySpec { if v != nil { @@ -4533,6 +5086,12 @@ func (i ValidatingAdmissionPolicySpecPatchArgs) ToValidatingAdmissionPolicySpecP return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecPatchOutput) } +func (i ValidatingAdmissionPolicySpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicySpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicySpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicySpecPatchArgs) ToValidatingAdmissionPolicySpecPatchPtrOutput() ValidatingAdmissionPolicySpecPatchPtrOutput { return i.ToValidatingAdmissionPolicySpecPatchPtrOutputWithContext(context.Background()) } @@ -4574,6 +5133,12 @@ func (i *validatingAdmissionPolicySpecPatchPtrType) ToValidatingAdmissionPolicyS return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecPatchPtrOutput) } +func (i *validatingAdmissionPolicySpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicySpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicySpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicySpec is the specification of the desired behavior of the AdmissionPolicy. type ValidatingAdmissionPolicySpecPatchOutput struct{ *pulumi.OutputState } @@ -4599,6 +5164,12 @@ func (o ValidatingAdmissionPolicySpecPatchOutput) ToValidatingAdmissionPolicySpe }).(ValidatingAdmissionPolicySpecPatchPtrOutput) } +func (o ValidatingAdmissionPolicySpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + // auditAnnotations contains CEL expressions which are used to produce audit annotations for the audit event of the API request. validations and auditAnnotations may not both be empty; a least one of validations or auditAnnotations is required. func (o ValidatingAdmissionPolicySpecPatchOutput) AuditAnnotations() AuditAnnotationPatchArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicySpecPatch) []AuditAnnotationPatch { return v.AuditAnnotations }).(AuditAnnotationPatchArrayOutput) @@ -4667,6 +5238,12 @@ func (o ValidatingAdmissionPolicySpecPatchPtrOutput) ToValidatingAdmissionPolicy return o } +func (o ValidatingAdmissionPolicySpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicySpecPatchPtrOutput) Elem() ValidatingAdmissionPolicySpecPatchOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicySpecPatch) ValidatingAdmissionPolicySpecPatch { if v != nil { @@ -4809,6 +5386,12 @@ func (i ValidatingAdmissionPolicyStatusArgs) ToValidatingAdmissionPolicyStatusOu return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusOutput) } +func (i ValidatingAdmissionPolicyStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatus] { + return pulumix.Output[ValidatingAdmissionPolicyStatus]{ + OutputState: i.ToValidatingAdmissionPolicyStatusOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyStatusArgs) ToValidatingAdmissionPolicyStatusPtrOutput() ValidatingAdmissionPolicyStatusPtrOutput { return i.ToValidatingAdmissionPolicyStatusPtrOutputWithContext(context.Background()) } @@ -4850,6 +5433,12 @@ func (i *validatingAdmissionPolicyStatusPtrType) ToValidatingAdmissionPolicyStat return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusPtrOutput) } +func (i *validatingAdmissionPolicyStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatus] { + return pulumix.Output[*ValidatingAdmissionPolicyStatus]{ + OutputState: i.ToValidatingAdmissionPolicyStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyStatus represents the status of a ValidatingAdmissionPolicy. type ValidatingAdmissionPolicyStatusOutput struct{ *pulumi.OutputState } @@ -4875,6 +5464,12 @@ func (o ValidatingAdmissionPolicyStatusOutput) ToValidatingAdmissionPolicyStatus }).(ValidatingAdmissionPolicyStatusPtrOutput) } +func (o ValidatingAdmissionPolicyStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatus] { + return pulumix.Output[ValidatingAdmissionPolicyStatus]{ + OutputState: o.OutputState, + } +} + // The conditions represent the latest available observations of a policy's current state. func (o ValidatingAdmissionPolicyStatusOutput) Conditions() metav1.ConditionArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyStatus) []metav1.Condition { return v.Conditions }).(metav1.ConditionArrayOutput) @@ -4904,6 +5499,12 @@ func (o ValidatingAdmissionPolicyStatusPtrOutput) ToValidatingAdmissionPolicySta return o } +func (o ValidatingAdmissionPolicyStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatus] { + return pulumix.Output[*ValidatingAdmissionPolicyStatus]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyStatusPtrOutput) Elem() ValidatingAdmissionPolicyStatusOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyStatus) ValidatingAdmissionPolicyStatus { if v != nil { @@ -4987,6 +5588,12 @@ func (i ValidatingAdmissionPolicyStatusPatchArgs) ToValidatingAdmissionPolicySta return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusPatchOutput) } +func (i ValidatingAdmissionPolicyStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[ValidatingAdmissionPolicyStatusPatch]{ + OutputState: i.ToValidatingAdmissionPolicyStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyStatusPatchArgs) ToValidatingAdmissionPolicyStatusPatchPtrOutput() ValidatingAdmissionPolicyStatusPatchPtrOutput { return i.ToValidatingAdmissionPolicyStatusPatchPtrOutputWithContext(context.Background()) } @@ -5028,6 +5635,12 @@ func (i *validatingAdmissionPolicyStatusPatchPtrType) ToValidatingAdmissionPolic return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusPatchPtrOutput) } +func (i *validatingAdmissionPolicyStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyStatusPatch]{ + OutputState: i.ToValidatingAdmissionPolicyStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyStatus represents the status of a ValidatingAdmissionPolicy. type ValidatingAdmissionPolicyStatusPatchOutput struct{ *pulumi.OutputState } @@ -5053,6 +5666,12 @@ func (o ValidatingAdmissionPolicyStatusPatchOutput) ToValidatingAdmissionPolicyS }).(ValidatingAdmissionPolicyStatusPatchPtrOutput) } +func (o ValidatingAdmissionPolicyStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[ValidatingAdmissionPolicyStatusPatch]{ + OutputState: o.OutputState, + } +} + // The conditions represent the latest available observations of a policy's current state. func (o ValidatingAdmissionPolicyStatusPatchOutput) Conditions() metav1.ConditionPatchArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyStatusPatch) []metav1.ConditionPatch { return v.Conditions }).(metav1.ConditionPatchArrayOutput) @@ -5082,6 +5701,12 @@ func (o ValidatingAdmissionPolicyStatusPatchPtrOutput) ToValidatingAdmissionPoli return o } +func (o ValidatingAdmissionPolicyStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyStatusPatchPtrOutput) Elem() ValidatingAdmissionPolicyStatusPatchOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyStatusPatch) ValidatingAdmissionPolicyStatusPatch { if v != nil { @@ -5219,6 +5844,12 @@ func (i ValidationArgs) ToValidationOutputWithContext(ctx context.Context) Valid return pulumi.ToOutputWithContext(ctx, i).(ValidationOutput) } +func (i ValidationArgs) ToOutput(ctx context.Context) pulumix.Output[Validation] { + return pulumix.Output[Validation]{ + OutputState: i.ToValidationOutputWithContext(ctx).OutputState, + } +} + // ValidationArrayInput is an input type that accepts ValidationArray and ValidationArrayOutput values. // You can construct a concrete instance of `ValidationArrayInput` via: // @@ -5244,6 +5875,12 @@ func (i ValidationArray) ToValidationArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ValidationArrayOutput) } +func (i ValidationArray) ToOutput(ctx context.Context) pulumix.Output[[]Validation] { + return pulumix.Output[[]Validation]{ + OutputState: i.ToValidationArrayOutputWithContext(ctx).OutputState, + } +} + // Validation specifies the CEL expression which is used to apply the validation. type ValidationOutput struct{ *pulumi.OutputState } @@ -5259,6 +5896,12 @@ func (o ValidationOutput) ToValidationOutputWithContext(ctx context.Context) Val return o } +func (o ValidationOutput) ToOutput(ctx context.Context) pulumix.Output[Validation] { + return pulumix.Output[Validation]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec CEL expressions have access to the contents of the API request/response, organized into CEL variables as well as some other useful variables: // // - 'object' - The object from the incoming request. The value is null for DELETE requests. - 'oldObject' - The existing object. The value is null for CREATE requests. - 'request' - Attributes of the API request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value. @@ -5320,6 +5963,12 @@ func (o ValidationArrayOutput) ToValidationArrayOutputWithContext(ctx context.Co return o } +func (o ValidationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Validation] { + return pulumix.Output[[]Validation]{ + OutputState: o.OutputState, + } +} + func (o ValidationArrayOutput) Index(i pulumi.IntInput) ValidationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Validation { return vs[0].([]Validation)[vs[1].(int)] @@ -5423,6 +6072,12 @@ func (i ValidationPatchArgs) ToValidationPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ValidationPatchOutput) } +func (i ValidationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidationPatch] { + return pulumix.Output[ValidationPatch]{ + OutputState: i.ToValidationPatchOutputWithContext(ctx).OutputState, + } +} + // ValidationPatchArrayInput is an input type that accepts ValidationPatchArray and ValidationPatchArrayOutput values. // You can construct a concrete instance of `ValidationPatchArrayInput` via: // @@ -5448,6 +6103,12 @@ func (i ValidationPatchArray) ToValidationPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ValidationPatchArrayOutput) } +func (i ValidationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidationPatch] { + return pulumix.Output[[]ValidationPatch]{ + OutputState: i.ToValidationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Validation specifies the CEL expression which is used to apply the validation. type ValidationPatchOutput struct{ *pulumi.OutputState } @@ -5463,6 +6124,12 @@ func (o ValidationPatchOutput) ToValidationPatchOutputWithContext(ctx context.Co return o } +func (o ValidationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidationPatch] { + return pulumix.Output[ValidationPatch]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec CEL expressions have access to the contents of the API request/response, organized into CEL variables as well as some other useful variables: // // - 'object' - The object from the incoming request. The value is null for DELETE requests. - 'oldObject' - The existing object. The value is null for CREATE requests. - 'request' - Attributes of the API request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value. @@ -5524,6 +6191,12 @@ func (o ValidationPatchArrayOutput) ToValidationPatchArrayOutputWithContext(ctx return o } +func (o ValidationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidationPatch] { + return pulumix.Output[[]ValidationPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidationPatchArrayOutput) Index(i pulumi.IntInput) ValidationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidationPatch { return vs[0].([]ValidationPatch)[vs[1].(int)] @@ -5569,6 +6242,12 @@ func (i VariableArgs) ToVariableOutputWithContext(ctx context.Context) VariableO return pulumi.ToOutputWithContext(ctx, i).(VariableOutput) } +func (i VariableArgs) ToOutput(ctx context.Context) pulumix.Output[Variable] { + return pulumix.Output[Variable]{ + OutputState: i.ToVariableOutputWithContext(ctx).OutputState, + } +} + // VariableArrayInput is an input type that accepts VariableArray and VariableArrayOutput values. // You can construct a concrete instance of `VariableArrayInput` via: // @@ -5594,6 +6273,12 @@ func (i VariableArray) ToVariableArrayOutputWithContext(ctx context.Context) Var return pulumi.ToOutputWithContext(ctx, i).(VariableArrayOutput) } +func (i VariableArray) ToOutput(ctx context.Context) pulumix.Output[[]Variable] { + return pulumix.Output[[]Variable]{ + OutputState: i.ToVariableArrayOutputWithContext(ctx).OutputState, + } +} + // Variable is the definition of a variable that is used for composition. type VariableOutput struct{ *pulumi.OutputState } @@ -5609,6 +6294,12 @@ func (o VariableOutput) ToVariableOutputWithContext(ctx context.Context) Variabl return o } +func (o VariableOutput) ToOutput(ctx context.Context) pulumix.Output[Variable] { + return pulumix.Output[Variable]{ + OutputState: o.OutputState, + } +} + // Expression is the expression that will be evaluated as the value of the variable. The CEL expression has access to the same identifiers as the CEL expressions in Validation. func (o VariableOutput) Expression() pulumi.StringOutput { return o.ApplyT(func(v Variable) string { return v.Expression }).(pulumi.StringOutput) @@ -5633,6 +6324,12 @@ func (o VariableArrayOutput) ToVariableArrayOutputWithContext(ctx context.Contex return o } +func (o VariableArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Variable] { + return pulumix.Output[[]Variable]{ + OutputState: o.OutputState, + } +} + func (o VariableArrayOutput) Index(i pulumi.IntInput) VariableOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Variable { return vs[0].([]Variable)[vs[1].(int)] @@ -5678,6 +6375,12 @@ func (i VariablePatchArgs) ToVariablePatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(VariablePatchOutput) } +func (i VariablePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VariablePatch] { + return pulumix.Output[VariablePatch]{ + OutputState: i.ToVariablePatchOutputWithContext(ctx).OutputState, + } +} + // VariablePatchArrayInput is an input type that accepts VariablePatchArray and VariablePatchArrayOutput values. // You can construct a concrete instance of `VariablePatchArrayInput` via: // @@ -5703,6 +6406,12 @@ func (i VariablePatchArray) ToVariablePatchArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VariablePatchArrayOutput) } +func (i VariablePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]VariablePatch] { + return pulumix.Output[[]VariablePatch]{ + OutputState: i.ToVariablePatchArrayOutputWithContext(ctx).OutputState, + } +} + // Variable is the definition of a variable that is used for composition. type VariablePatchOutput struct{ *pulumi.OutputState } @@ -5718,6 +6427,12 @@ func (o VariablePatchOutput) ToVariablePatchOutputWithContext(ctx context.Contex return o } +func (o VariablePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VariablePatch] { + return pulumix.Output[VariablePatch]{ + OutputState: o.OutputState, + } +} + // Expression is the expression that will be evaluated as the value of the variable. The CEL expression has access to the same identifiers as the CEL expressions in Validation. func (o VariablePatchOutput) Expression() pulumi.StringPtrOutput { return o.ApplyT(func(v VariablePatch) *string { return v.Expression }).(pulumi.StringPtrOutput) @@ -5742,6 +6457,12 @@ func (o VariablePatchArrayOutput) ToVariablePatchArrayOutputWithContext(ctx cont return o } +func (o VariablePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VariablePatch] { + return pulumix.Output[[]VariablePatch]{ + OutputState: o.OutputState, + } +} + func (o VariablePatchArrayOutput) Index(i pulumi.IntInput) VariablePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VariablePatch { return vs[0].([]VariablePatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicy.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicy.go index ff4245a06f..c421ba27b3 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicy.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicy.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicy describes the definition of an admission validation policy that accepts or rejects an object without changing it. @@ -121,6 +122,12 @@ func (i *ValidatingAdmissionPolicy) ToValidatingAdmissionPolicyOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyOutput) } +func (i *ValidatingAdmissionPolicy) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicy] { + return pulumix.Output[*ValidatingAdmissionPolicy]{ + OutputState: i.ToValidatingAdmissionPolicyOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyArrayInput is an input type that accepts ValidatingAdmissionPolicyArray and ValidatingAdmissionPolicyArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyArrayInput` via: // @@ -146,6 +153,12 @@ func (i ValidatingAdmissionPolicyArray) ToValidatingAdmissionPolicyArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyArrayOutput) } +func (i ValidatingAdmissionPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicy] { + return pulumix.Output[[]*ValidatingAdmissionPolicy]{ + OutputState: i.ToValidatingAdmissionPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyMapInput is an input type that accepts ValidatingAdmissionPolicyMap and ValidatingAdmissionPolicyMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyMapInput` via: // @@ -171,6 +184,12 @@ func (i ValidatingAdmissionPolicyMap) ToValidatingAdmissionPolicyMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyMapOutput) } +func (i ValidatingAdmissionPolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicy] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicy]{ + OutputState: i.ToValidatingAdmissionPolicyMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o ValidatingAdmissionPolicyOutput) ToValidatingAdmissionPolicyOutputWithCo return o } +func (o ValidatingAdmissionPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicy] { + return pulumix.Output[*ValidatingAdmissionPolicy]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicy) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o ValidatingAdmissionPolicyArrayOutput) ToValidatingAdmissionPolicyArrayOu return o } +func (o ValidatingAdmissionPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicy] { + return pulumix.Output[[]*ValidatingAdmissionPolicy]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicy { return vs[0].([]*ValidatingAdmissionPolicy)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o ValidatingAdmissionPolicyMapOutput) ToValidatingAdmissionPolicyMapOutput return o } +func (o ValidatingAdmissionPolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicy] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicy]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicy { return vs[0].(map[string]*ValidatingAdmissionPolicy)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBinding.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBinding.go index 17e02afbed..87f591ada6 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBinding.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBinding.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicyBinding binds the ValidatingAdmissionPolicy with paramerized resources. ValidatingAdmissionPolicyBinding and parameter CRDs together define how cluster administrators configure policies for clusters. @@ -123,6 +124,12 @@ func (i *ValidatingAdmissionPolicyBinding) ToValidatingAdmissionPolicyBindingOut return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingOutput) } +func (i *ValidatingAdmissionPolicyBinding) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[*ValidatingAdmissionPolicyBinding]{ + OutputState: i.ToValidatingAdmissionPolicyBindingOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingArray and ValidatingAdmissionPolicyBindingArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingArrayInput` via: // @@ -148,6 +155,12 @@ func (i ValidatingAdmissionPolicyBindingArray) ToValidatingAdmissionPolicyBindin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingArrayOutput) } +func (i ValidatingAdmissionPolicyBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBinding]{ + OutputState: i.ToValidatingAdmissionPolicyBindingArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingMapInput is an input type that accepts ValidatingAdmissionPolicyBindingMap and ValidatingAdmissionPolicyBindingMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingMapInput` via: // @@ -173,6 +186,12 @@ func (i ValidatingAdmissionPolicyBindingMap) ToValidatingAdmissionPolicyBindingM return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingMapOutput) } +func (i ValidatingAdmissionPolicyBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding]{ + OutputState: i.ToValidatingAdmissionPolicyBindingMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyBindingOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyBindingOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o ValidatingAdmissionPolicyBindingOutput) ToValidatingAdmissionPolicyBindi return o } +func (o ValidatingAdmissionPolicyBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[*ValidatingAdmissionPolicyBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -221,6 +246,12 @@ func (o ValidatingAdmissionPolicyBindingArrayOutput) ToValidatingAdmissionPolicy return o } +func (o ValidatingAdmissionPolicyBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBinding]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBinding { return vs[0].([]*ValidatingAdmissionPolicyBinding)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o ValidatingAdmissionPolicyBindingMapOutput) ToValidatingAdmissionPolicyBi return o } +func (o ValidatingAdmissionPolicyBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBinding { return vs[0].(map[string]*ValidatingAdmissionPolicyBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingList.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingList.go index 1015c9c848..154a4f9ce5 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingList.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingList.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicyBindingList is a list of ValidatingAdmissionPolicyBinding. @@ -113,6 +114,12 @@ func (i *ValidatingAdmissionPolicyBindingList) ToValidatingAdmissionPolicyBindin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListOutput) } +func (i *ValidatingAdmissionPolicyBindingList) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingList]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingListArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingListArray and ValidatingAdmissionPolicyBindingListArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingListArrayInput` via: // @@ -138,6 +145,12 @@ func (i ValidatingAdmissionPolicyBindingListArray) ToValidatingAdmissionPolicyBi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListArrayOutput) } +func (i ValidatingAdmissionPolicyBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingList]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingListMapInput is an input type that accepts ValidatingAdmissionPolicyBindingListMap and ValidatingAdmissionPolicyBindingListMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingListMapInput` via: // @@ -163,6 +176,12 @@ func (i ValidatingAdmissionPolicyBindingListMap) ToValidatingAdmissionPolicyBind return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListMapOutput) } +func (i ValidatingAdmissionPolicyBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyBindingListOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyBindingListOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o ValidatingAdmissionPolicyBindingListOutput) ToValidatingAdmissionPolicyB return o } +func (o ValidatingAdmissionPolicyBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -213,6 +238,12 @@ func (o ValidatingAdmissionPolicyBindingListArrayOutput) ToValidatingAdmissionPo return o } +func (o ValidatingAdmissionPolicyBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingListArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingList { return vs[0].([]*ValidatingAdmissionPolicyBindingList)[vs[1].(int)] @@ -233,6 +264,12 @@ func (o ValidatingAdmissionPolicyBindingListMapOutput) ToValidatingAdmissionPoli return o } +func (o ValidatingAdmissionPolicyBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingListMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingList { return vs[0].(map[string]*ValidatingAdmissionPolicyBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingPatch.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingPatch.go index 9bbf1c373a..478da286b5 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -129,6 +130,12 @@ func (i *ValidatingAdmissionPolicyBindingPatch) ToValidatingAdmissionPolicyBindi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchOutput) } +func (i *ValidatingAdmissionPolicyBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingPatchArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingPatchArray and ValidatingAdmissionPolicyBindingPatchArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingPatchArrayInput` via: // @@ -154,6 +161,12 @@ func (i ValidatingAdmissionPolicyBindingPatchArray) ToValidatingAdmissionPolicyB return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchArrayOutput) } +func (i ValidatingAdmissionPolicyBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingPatchMapInput is an input type that accepts ValidatingAdmissionPolicyBindingPatchMap and ValidatingAdmissionPolicyBindingPatchMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingPatchMapInput` via: // @@ -179,6 +192,12 @@ func (i ValidatingAdmissionPolicyBindingPatchMap) ToValidatingAdmissionPolicyBin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchMapOutput) } +func (i ValidatingAdmissionPolicyBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyBindingPatchOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyBindingPatchOutput) ElementType() reflect.Type { @@ -193,6 +212,12 @@ func (o ValidatingAdmissionPolicyBindingPatchOutput) ToValidatingAdmissionPolicy return o } +func (o ValidatingAdmissionPolicyBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -229,6 +254,12 @@ func (o ValidatingAdmissionPolicyBindingPatchArrayOutput) ToValidatingAdmissionP return o } +func (o ValidatingAdmissionPolicyBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingPatchArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingPatch { return vs[0].([]*ValidatingAdmissionPolicyBindingPatch)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o ValidatingAdmissionPolicyBindingPatchMapOutput) ToValidatingAdmissionPol return o } +func (o ValidatingAdmissionPolicyBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingPatchMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingPatch { return vs[0].(map[string]*ValidatingAdmissionPolicyBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyList.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyList.go index d86b3ae656..a27099e08c 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyList.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyList.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicyList is a list of ValidatingAdmissionPolicy. @@ -113,6 +114,12 @@ func (i *ValidatingAdmissionPolicyList) ToValidatingAdmissionPolicyListOutputWit return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListOutput) } +func (i *ValidatingAdmissionPolicyList) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyList] { + return pulumix.Output[*ValidatingAdmissionPolicyList]{ + OutputState: i.ToValidatingAdmissionPolicyListOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyListArrayInput is an input type that accepts ValidatingAdmissionPolicyListArray and ValidatingAdmissionPolicyListArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyListArrayInput` via: // @@ -138,6 +145,12 @@ func (i ValidatingAdmissionPolicyListArray) ToValidatingAdmissionPolicyListArray return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListArrayOutput) } +func (i ValidatingAdmissionPolicyListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyList]{ + OutputState: i.ToValidatingAdmissionPolicyListArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyListMapInput is an input type that accepts ValidatingAdmissionPolicyListMap and ValidatingAdmissionPolicyListMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyListMapInput` via: // @@ -163,6 +176,12 @@ func (i ValidatingAdmissionPolicyListMap) ToValidatingAdmissionPolicyListMapOutp return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListMapOutput) } +func (i ValidatingAdmissionPolicyListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyList]{ + OutputState: i.ToValidatingAdmissionPolicyListMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyListOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyListOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o ValidatingAdmissionPolicyListOutput) ToValidatingAdmissionPolicyListOutp return o } +func (o ValidatingAdmissionPolicyListOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyList] { + return pulumix.Output[*ValidatingAdmissionPolicyList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o ValidatingAdmissionPolicyListArrayOutput) ToValidatingAdmissionPolicyLis return o } +func (o ValidatingAdmissionPolicyListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyListArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyList { return vs[0].([]*ValidatingAdmissionPolicyList)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o ValidatingAdmissionPolicyListMapOutput) ToValidatingAdmissionPolicyListM return o } +func (o ValidatingAdmissionPolicyListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyListMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyList { return vs[0].(map[string]*ValidatingAdmissionPolicyList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyPatch.go b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyPatch.go index ece8aad506..9df7c0c846 100644 --- a/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1alpha1/validatingAdmissionPolicyPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -127,6 +128,12 @@ func (i *ValidatingAdmissionPolicyPatch) ToValidatingAdmissionPolicyPatchOutputW return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchOutput) } +func (i *ValidatingAdmissionPolicyPatch) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyPatch]{ + OutputState: i.ToValidatingAdmissionPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyPatchArrayInput is an input type that accepts ValidatingAdmissionPolicyPatchArray and ValidatingAdmissionPolicyPatchArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyPatchArrayInput` via: // @@ -152,6 +159,12 @@ func (i ValidatingAdmissionPolicyPatchArray) ToValidatingAdmissionPolicyPatchArr return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchArrayOutput) } +func (i ValidatingAdmissionPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyPatch]{ + OutputState: i.ToValidatingAdmissionPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyPatchMapInput is an input type that accepts ValidatingAdmissionPolicyPatchMap and ValidatingAdmissionPolicyPatchMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyPatchMapInput` via: // @@ -177,6 +190,12 @@ func (i ValidatingAdmissionPolicyPatchMap) ToValidatingAdmissionPolicyPatchMapOu return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchMapOutput) } +func (i ValidatingAdmissionPolicyPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch]{ + OutputState: i.ToValidatingAdmissionPolicyPatchMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyPatchOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyPatchOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o ValidatingAdmissionPolicyPatchOutput) ToValidatingAdmissionPolicyPatchOu return o } +func (o ValidatingAdmissionPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -230,6 +255,12 @@ func (o ValidatingAdmissionPolicyPatchArrayOutput) ToValidatingAdmissionPolicyPa return o } +func (o ValidatingAdmissionPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyPatchArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyPatch { return vs[0].([]*ValidatingAdmissionPolicyPatch)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o ValidatingAdmissionPolicyPatchMapOutput) ToValidatingAdmissionPolicyPatc return o } +func (o ValidatingAdmissionPolicyPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyPatchMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyPatch { return vs[0].(map[string]*ValidatingAdmissionPolicyPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfiguration.go b/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfiguration.go index 4e454425ac..b98a21c202 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfiguration.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 MutatingWebhookConfiguration instead. @@ -119,6 +120,12 @@ func (i *MutatingWebhookConfiguration) ToMutatingWebhookConfigurationOutputWithC return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationOutput) } +func (i *MutatingWebhookConfiguration) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfiguration] { + return pulumix.Output[*MutatingWebhookConfiguration]{ + OutputState: i.ToMutatingWebhookConfigurationOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationArrayInput is an input type that accepts MutatingWebhookConfigurationArray and MutatingWebhookConfigurationArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationArrayInput` via: // @@ -144,6 +151,12 @@ func (i MutatingWebhookConfigurationArray) ToMutatingWebhookConfigurationArrayOu return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationArrayOutput) } +func (i MutatingWebhookConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfiguration] { + return pulumix.Output[[]*MutatingWebhookConfiguration]{ + OutputState: i.ToMutatingWebhookConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationMapInput is an input type that accepts MutatingWebhookConfigurationMap and MutatingWebhookConfigurationMapOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationMapInput` via: // @@ -169,6 +182,12 @@ func (i MutatingWebhookConfigurationMap) ToMutatingWebhookConfigurationMapOutput return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationMapOutput) } +func (i MutatingWebhookConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfiguration] { + return pulumix.Output[map[string]*MutatingWebhookConfiguration]{ + OutputState: i.ToMutatingWebhookConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type MutatingWebhookConfigurationOutput struct{ *pulumi.OutputState } func (MutatingWebhookConfigurationOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o MutatingWebhookConfigurationOutput) ToMutatingWebhookConfigurationOutput return o } +func (o MutatingWebhookConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfiguration] { + return pulumix.Output[*MutatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *MutatingWebhookConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o MutatingWebhookConfigurationArrayOutput) ToMutatingWebhookConfigurationA return o } +func (o MutatingWebhookConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfiguration] { + return pulumix.Output[[]*MutatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MutatingWebhookConfiguration { return vs[0].([]*MutatingWebhookConfiguration)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o MutatingWebhookConfigurationMapOutput) ToMutatingWebhookConfigurationMap return o } +func (o MutatingWebhookConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfiguration] { + return pulumix.Output[map[string]*MutatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationMapOutput) MapIndex(k pulumi.StringInput) MutatingWebhookConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MutatingWebhookConfiguration { return vs[0].(map[string]*MutatingWebhookConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationList.go b/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationList.go index 63ee6fb3fa..88b174a9f7 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationList.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. @@ -117,6 +118,12 @@ func (i *MutatingWebhookConfigurationList) ToMutatingWebhookConfigurationListOut return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListOutput) } +func (i *MutatingWebhookConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationList] { + return pulumix.Output[*MutatingWebhookConfigurationList]{ + OutputState: i.ToMutatingWebhookConfigurationListOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationListArrayInput is an input type that accepts MutatingWebhookConfigurationListArray and MutatingWebhookConfigurationListArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i MutatingWebhookConfigurationListArray) ToMutatingWebhookConfigurationLis return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListArrayOutput) } +func (i MutatingWebhookConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationList] { + return pulumix.Output[[]*MutatingWebhookConfigurationList]{ + OutputState: i.ToMutatingWebhookConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationListMapInput is an input type that accepts MutatingWebhookConfigurationListMap and MutatingWebhookConfigurationListMapOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i MutatingWebhookConfigurationListMap) ToMutatingWebhookConfigurationListM return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListMapOutput) } +func (i MutatingWebhookConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationList] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationList]{ + OutputState: i.ToMutatingWebhookConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type MutatingWebhookConfigurationListOutput struct{ *pulumi.OutputState } func (MutatingWebhookConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o MutatingWebhookConfigurationListOutput) ToMutatingWebhookConfigurationLi return o } +func (o MutatingWebhookConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationList] { + return pulumix.Output[*MutatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *MutatingWebhookConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o MutatingWebhookConfigurationListArrayOutput) ToMutatingWebhookConfigurat return o } +func (o MutatingWebhookConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationList] { + return pulumix.Output[[]*MutatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationListArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationList { return vs[0].([]*MutatingWebhookConfigurationList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o MutatingWebhookConfigurationListMapOutput) ToMutatingWebhookConfiguratio return o } +func (o MutatingWebhookConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationList] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationListMapOutput) MapIndex(k pulumi.StringInput) MutatingWebhookConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationList { return vs[0].(map[string]*MutatingWebhookConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationPatch.go b/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationPatch.go index f66f1409bb..6bfcd7a8ea 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/mutatingWebhookConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *MutatingWebhookConfigurationPatch) ToMutatingWebhookConfigurationPatchO return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchOutput) } +func (i *MutatingWebhookConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationPatch] { + return pulumix.Output[*MutatingWebhookConfigurationPatch]{ + OutputState: i.ToMutatingWebhookConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationPatchArrayInput is an input type that accepts MutatingWebhookConfigurationPatchArray and MutatingWebhookConfigurationPatchArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i MutatingWebhookConfigurationPatchArray) ToMutatingWebhookConfigurationPa return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchArrayOutput) } +func (i MutatingWebhookConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[[]*MutatingWebhookConfigurationPatch]{ + OutputState: i.ToMutatingWebhookConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationPatchMapInput is an input type that accepts MutatingWebhookConfigurationPatchMap and MutatingWebhookConfigurationPatchMapOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i MutatingWebhookConfigurationPatchMap) ToMutatingWebhookConfigurationPatc return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchMapOutput) } +func (i MutatingWebhookConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationPatch]{ + OutputState: i.ToMutatingWebhookConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type MutatingWebhookConfigurationPatchOutput struct{ *pulumi.OutputState } func (MutatingWebhookConfigurationPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o MutatingWebhookConfigurationPatchOutput) ToMutatingWebhookConfigurationP return o } +func (o MutatingWebhookConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*MutatingWebhookConfigurationPatch] { + return pulumix.Output[*MutatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *MutatingWebhookConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o MutatingWebhookConfigurationPatchArrayOutput) ToMutatingWebhookConfigura return o } +func (o MutatingWebhookConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[[]*MutatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationPatchArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationPatch { return vs[0].([]*MutatingWebhookConfigurationPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o MutatingWebhookConfigurationPatchMapOutput) ToMutatingWebhookConfigurati return o } +func (o MutatingWebhookConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*MutatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*MutatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) MutatingWebhookConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MutatingWebhookConfigurationPatch { return vs[0].(map[string]*MutatingWebhookConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/admissionregistration/v1beta1/pulumiTypes.go index 1029ccdb2b..30c9d69d48 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -73,6 +74,12 @@ func (i AuditAnnotationArgs) ToAuditAnnotationOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationOutput) } +func (i AuditAnnotationArgs) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotation] { + return pulumix.Output[AuditAnnotation]{ + OutputState: i.ToAuditAnnotationOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotationArrayInput is an input type that accepts AuditAnnotationArray and AuditAnnotationArrayOutput values. // You can construct a concrete instance of `AuditAnnotationArrayInput` via: // @@ -98,6 +105,12 @@ func (i AuditAnnotationArray) ToAuditAnnotationArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationArrayOutput) } +func (i AuditAnnotationArray) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotation] { + return pulumix.Output[[]AuditAnnotation]{ + OutputState: i.ToAuditAnnotationArrayOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotation describes how to produce an audit annotation for an API request. type AuditAnnotationOutput struct{ *pulumi.OutputState } @@ -113,6 +126,12 @@ func (o AuditAnnotationOutput) ToAuditAnnotationOutputWithContext(ctx context.Co return o } +func (o AuditAnnotationOutput) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotation] { + return pulumix.Output[AuditAnnotation]{ + OutputState: o.OutputState, + } +} + // key specifies the audit annotation key. The audit annotation keys of a ValidatingAdmissionPolicy must be unique. The key must be a qualified name ([A-Za-z0-9][-A-Za-z0-9_.]*) no more than 63 bytes in length. // // The key is combined with the resource name of the ValidatingAdmissionPolicy to construct an audit annotation key: "{ValidatingAdmissionPolicy name}/{key}". @@ -147,6 +166,12 @@ func (o AuditAnnotationArrayOutput) ToAuditAnnotationArrayOutputWithContext(ctx return o } +func (o AuditAnnotationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotation] { + return pulumix.Output[[]AuditAnnotation]{ + OutputState: o.OutputState, + } +} + func (o AuditAnnotationArrayOutput) Index(i pulumi.IntInput) AuditAnnotationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditAnnotation { return vs[0].([]AuditAnnotation)[vs[1].(int)] @@ -212,6 +237,12 @@ func (i AuditAnnotationPatchArgs) ToAuditAnnotationPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationPatchOutput) } +func (i AuditAnnotationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotationPatch] { + return pulumix.Output[AuditAnnotationPatch]{ + OutputState: i.ToAuditAnnotationPatchOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotationPatchArrayInput is an input type that accepts AuditAnnotationPatchArray and AuditAnnotationPatchArrayOutput values. // You can construct a concrete instance of `AuditAnnotationPatchArrayInput` via: // @@ -237,6 +268,12 @@ func (i AuditAnnotationPatchArray) ToAuditAnnotationPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(AuditAnnotationPatchArrayOutput) } +func (i AuditAnnotationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotationPatch] { + return pulumix.Output[[]AuditAnnotationPatch]{ + OutputState: i.ToAuditAnnotationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AuditAnnotation describes how to produce an audit annotation for an API request. type AuditAnnotationPatchOutput struct{ *pulumi.OutputState } @@ -252,6 +289,12 @@ func (o AuditAnnotationPatchOutput) ToAuditAnnotationPatchOutputWithContext(ctx return o } +func (o AuditAnnotationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AuditAnnotationPatch] { + return pulumix.Output[AuditAnnotationPatch]{ + OutputState: o.OutputState, + } +} + // key specifies the audit annotation key. The audit annotation keys of a ValidatingAdmissionPolicy must be unique. The key must be a qualified name ([A-Za-z0-9][-A-Za-z0-9_.]*) no more than 63 bytes in length. // // The key is combined with the resource name of the ValidatingAdmissionPolicy to construct an audit annotation key: "{ValidatingAdmissionPolicy name}/{key}". @@ -286,6 +329,12 @@ func (o AuditAnnotationPatchArrayOutput) ToAuditAnnotationPatchArrayOutputWithCo return o } +func (o AuditAnnotationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AuditAnnotationPatch] { + return pulumix.Output[[]AuditAnnotationPatch]{ + OutputState: o.OutputState, + } +} + func (o AuditAnnotationPatchArrayOutput) Index(i pulumi.IntInput) AuditAnnotationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditAnnotationPatch { return vs[0].([]AuditAnnotationPatch)[vs[1].(int)] @@ -331,6 +380,12 @@ func (i ExpressionWarningArgs) ToExpressionWarningOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningOutput) } +func (i ExpressionWarningArgs) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarning] { + return pulumix.Output[ExpressionWarning]{ + OutputState: i.ToExpressionWarningOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarningArrayInput is an input type that accepts ExpressionWarningArray and ExpressionWarningArrayOutput values. // You can construct a concrete instance of `ExpressionWarningArrayInput` via: // @@ -356,6 +411,12 @@ func (i ExpressionWarningArray) ToExpressionWarningArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningArrayOutput) } +func (i ExpressionWarningArray) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarning] { + return pulumix.Output[[]ExpressionWarning]{ + OutputState: i.ToExpressionWarningArrayOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarning is a warning information that targets a specific expression. type ExpressionWarningOutput struct{ *pulumi.OutputState } @@ -371,6 +432,12 @@ func (o ExpressionWarningOutput) ToExpressionWarningOutputWithContext(ctx contex return o } +func (o ExpressionWarningOutput) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarning] { + return pulumix.Output[ExpressionWarning]{ + OutputState: o.OutputState, + } +} + // The path to the field that refers the expression. For example, the reference to the expression of the first item of validations is "spec.validations[0].expression" func (o ExpressionWarningOutput) FieldRef() pulumi.StringOutput { return o.ApplyT(func(v ExpressionWarning) string { return v.FieldRef }).(pulumi.StringOutput) @@ -395,6 +462,12 @@ func (o ExpressionWarningArrayOutput) ToExpressionWarningArrayOutputWithContext( return o } +func (o ExpressionWarningArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarning] { + return pulumix.Output[[]ExpressionWarning]{ + OutputState: o.OutputState, + } +} + func (o ExpressionWarningArrayOutput) Index(i pulumi.IntInput) ExpressionWarningOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ExpressionWarning { return vs[0].([]ExpressionWarning)[vs[1].(int)] @@ -440,6 +513,12 @@ func (i ExpressionWarningPatchArgs) ToExpressionWarningPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningPatchOutput) } +func (i ExpressionWarningPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarningPatch] { + return pulumix.Output[ExpressionWarningPatch]{ + OutputState: i.ToExpressionWarningPatchOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarningPatchArrayInput is an input type that accepts ExpressionWarningPatchArray and ExpressionWarningPatchArrayOutput values. // You can construct a concrete instance of `ExpressionWarningPatchArrayInput` via: // @@ -465,6 +544,12 @@ func (i ExpressionWarningPatchArray) ToExpressionWarningPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExpressionWarningPatchArrayOutput) } +func (i ExpressionWarningPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarningPatch] { + return pulumix.Output[[]ExpressionWarningPatch]{ + OutputState: i.ToExpressionWarningPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ExpressionWarning is a warning information that targets a specific expression. type ExpressionWarningPatchOutput struct{ *pulumi.OutputState } @@ -480,6 +565,12 @@ func (o ExpressionWarningPatchOutput) ToExpressionWarningPatchOutputWithContext( return o } +func (o ExpressionWarningPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExpressionWarningPatch] { + return pulumix.Output[ExpressionWarningPatch]{ + OutputState: o.OutputState, + } +} + // The path to the field that refers the expression. For example, the reference to the expression of the first item of validations is "spec.validations[0].expression" func (o ExpressionWarningPatchOutput) FieldRef() pulumi.StringPtrOutput { return o.ApplyT(func(v ExpressionWarningPatch) *string { return v.FieldRef }).(pulumi.StringPtrOutput) @@ -504,6 +595,12 @@ func (o ExpressionWarningPatchArrayOutput) ToExpressionWarningPatchArrayOutputWi return o } +func (o ExpressionWarningPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ExpressionWarningPatch] { + return pulumix.Output[[]ExpressionWarningPatch]{ + OutputState: o.OutputState, + } +} + func (o ExpressionWarningPatchArrayOutput) Index(i pulumi.IntInput) ExpressionWarningPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ExpressionWarningPatch { return vs[0].([]ExpressionWarningPatch)[vs[1].(int)] @@ -569,6 +666,12 @@ func (i MatchConditionArgs) ToMatchConditionOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(MatchConditionOutput) } +func (i MatchConditionArgs) ToOutput(ctx context.Context) pulumix.Output[MatchCondition] { + return pulumix.Output[MatchCondition]{ + OutputState: i.ToMatchConditionOutputWithContext(ctx).OutputState, + } +} + // MatchConditionArrayInput is an input type that accepts MatchConditionArray and MatchConditionArrayOutput values. // You can construct a concrete instance of `MatchConditionArrayInput` via: // @@ -594,6 +697,12 @@ func (i MatchConditionArray) ToMatchConditionArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MatchConditionArrayOutput) } +func (i MatchConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]MatchCondition] { + return pulumix.Output[[]MatchCondition]{ + OutputState: i.ToMatchConditionArrayOutputWithContext(ctx).OutputState, + } +} + // MatchCondition represents a condition which must be fulfilled for a request to be sent to a webhook. type MatchConditionOutput struct{ *pulumi.OutputState } @@ -609,6 +718,12 @@ func (o MatchConditionOutput) ToMatchConditionOutputWithContext(ctx context.Cont return o } +func (o MatchConditionOutput) ToOutput(ctx context.Context) pulumix.Output[MatchCondition] { + return pulumix.Output[MatchCondition]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. Must evaluate to bool. CEL expressions have access to the contents of the AdmissionRequest and Authorizer, organized into CEL variables: // // 'object' - The object from the incoming request. The value is null for DELETE requests. 'oldObject' - The existing object. The value is null for CREATE requests. 'request' - Attributes of the admission request(/pkg/apis/admission/types.go#AdmissionRequest). 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. @@ -647,6 +762,12 @@ func (o MatchConditionArrayOutput) ToMatchConditionArrayOutputWithContext(ctx co return o } +func (o MatchConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MatchCondition] { + return pulumix.Output[[]MatchCondition]{ + OutputState: o.OutputState, + } +} + func (o MatchConditionArrayOutput) Index(i pulumi.IntInput) MatchConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchCondition { return vs[0].([]MatchCondition)[vs[1].(int)] @@ -712,6 +833,12 @@ func (i MatchConditionPatchArgs) ToMatchConditionPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(MatchConditionPatchOutput) } +func (i MatchConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MatchConditionPatch] { + return pulumix.Output[MatchConditionPatch]{ + OutputState: i.ToMatchConditionPatchOutputWithContext(ctx).OutputState, + } +} + // MatchConditionPatchArrayInput is an input type that accepts MatchConditionPatchArray and MatchConditionPatchArrayOutput values. // You can construct a concrete instance of `MatchConditionPatchArrayInput` via: // @@ -737,6 +864,12 @@ func (i MatchConditionPatchArray) ToMatchConditionPatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(MatchConditionPatchArrayOutput) } +func (i MatchConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MatchConditionPatch] { + return pulumix.Output[[]MatchConditionPatch]{ + OutputState: i.ToMatchConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MatchCondition represents a condition which must be fulfilled for a request to be sent to a webhook. type MatchConditionPatchOutput struct{ *pulumi.OutputState } @@ -752,6 +885,12 @@ func (o MatchConditionPatchOutput) ToMatchConditionPatchOutputWithContext(ctx co return o } +func (o MatchConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MatchConditionPatch] { + return pulumix.Output[MatchConditionPatch]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. Must evaluate to bool. CEL expressions have access to the contents of the AdmissionRequest and Authorizer, organized into CEL variables: // // 'object' - The object from the incoming request. The value is null for DELETE requests. 'oldObject' - The existing object. The value is null for CREATE requests. 'request' - Attributes of the admission request(/pkg/apis/admission/types.go#AdmissionRequest). 'authorizer' - A CEL Authorizer. May be used to perform authorization checks for the principal (user or service account) of the request. @@ -790,6 +929,12 @@ func (o MatchConditionPatchArrayOutput) ToMatchConditionPatchArrayOutputWithCont return o } +func (o MatchConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MatchConditionPatch] { + return pulumix.Output[[]MatchConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o MatchConditionPatchArrayOutput) Index(i pulumi.IntInput) MatchConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchConditionPatch { return vs[0].([]MatchConditionPatch)[vs[1].(int)] @@ -919,6 +1064,12 @@ func (i MatchResourcesArgs) ToMatchResourcesOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesOutput) } +func (i MatchResourcesArgs) ToOutput(ctx context.Context) pulumix.Output[MatchResources] { + return pulumix.Output[MatchResources]{ + OutputState: i.ToMatchResourcesOutputWithContext(ctx).OutputState, + } +} + func (i MatchResourcesArgs) ToMatchResourcesPtrOutput() MatchResourcesPtrOutput { return i.ToMatchResourcesPtrOutputWithContext(context.Background()) } @@ -960,6 +1111,12 @@ func (i *matchResourcesPtrType) ToMatchResourcesPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesPtrOutput) } +func (i *matchResourcesPtrType) ToOutput(ctx context.Context) pulumix.Output[*MatchResources] { + return pulumix.Output[*MatchResources]{ + OutputState: i.ToMatchResourcesPtrOutputWithContext(ctx).OutputState, + } +} + // MatchResources decides whether to run the admission control policy on an object based on whether it meets the match criteria. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) type MatchResourcesOutput struct{ *pulumi.OutputState } @@ -985,6 +1142,12 @@ func (o MatchResourcesOutput) ToMatchResourcesPtrOutputWithContext(ctx context.C }).(MatchResourcesPtrOutput) } +func (o MatchResourcesOutput) ToOutput(ctx context.Context) pulumix.Output[MatchResources] { + return pulumix.Output[MatchResources]{ + OutputState: o.OutputState, + } +} + // ExcludeResourceRules describes what operations on what resources/subresources the ValidatingAdmissionPolicy should not care about. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) func (o MatchResourcesOutput) ExcludeResourceRules() NamedRuleWithOperationsArrayOutput { return o.ApplyT(func(v MatchResources) []NamedRuleWithOperations { return v.ExcludeResourceRules }).(NamedRuleWithOperationsArrayOutput) @@ -1060,6 +1223,12 @@ func (o MatchResourcesPtrOutput) ToMatchResourcesPtrOutputWithContext(ctx contex return o } +func (o MatchResourcesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MatchResources] { + return pulumix.Output[*MatchResources]{ + OutputState: o.OutputState, + } +} + func (o MatchResourcesPtrOutput) Elem() MatchResourcesOutput { return o.ApplyT(func(v *MatchResources) MatchResources { if v != nil { @@ -1279,6 +1448,12 @@ func (i MatchResourcesPatchArgs) ToMatchResourcesPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesPatchOutput) } +func (i MatchResourcesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MatchResourcesPatch] { + return pulumix.Output[MatchResourcesPatch]{ + OutputState: i.ToMatchResourcesPatchOutputWithContext(ctx).OutputState, + } +} + func (i MatchResourcesPatchArgs) ToMatchResourcesPatchPtrOutput() MatchResourcesPatchPtrOutput { return i.ToMatchResourcesPatchPtrOutputWithContext(context.Background()) } @@ -1320,6 +1495,12 @@ func (i *matchResourcesPatchPtrType) ToMatchResourcesPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(MatchResourcesPatchPtrOutput) } +func (i *matchResourcesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MatchResourcesPatch] { + return pulumix.Output[*MatchResourcesPatch]{ + OutputState: i.ToMatchResourcesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MatchResources decides whether to run the admission control policy on an object based on whether it meets the match criteria. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) type MatchResourcesPatchOutput struct{ *pulumi.OutputState } @@ -1345,6 +1526,12 @@ func (o MatchResourcesPatchOutput) ToMatchResourcesPatchPtrOutputWithContext(ctx }).(MatchResourcesPatchPtrOutput) } +func (o MatchResourcesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MatchResourcesPatch] { + return pulumix.Output[MatchResourcesPatch]{ + OutputState: o.OutputState, + } +} + // ExcludeResourceRules describes what operations on what resources/subresources the ValidatingAdmissionPolicy should not care about. The exclude rules take precedence over include rules (if a resource matches both, it is excluded) func (o MatchResourcesPatchOutput) ExcludeResourceRules() NamedRuleWithOperationsPatchArrayOutput { return o.ApplyT(func(v MatchResourcesPatch) []NamedRuleWithOperationsPatch { return v.ExcludeResourceRules }).(NamedRuleWithOperationsPatchArrayOutput) @@ -1420,6 +1607,12 @@ func (o MatchResourcesPatchPtrOutput) ToMatchResourcesPatchPtrOutputWithContext( return o } +func (o MatchResourcesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MatchResourcesPatch] { + return pulumix.Output[*MatchResourcesPatch]{ + OutputState: o.OutputState, + } +} + func (o MatchResourcesPatchPtrOutput) Elem() MatchResourcesPatchOutput { return o.ApplyT(func(v *MatchResourcesPatch) MatchResourcesPatch { if v != nil { @@ -1675,6 +1868,12 @@ func (i MutatingWebhookArgs) ToMutatingWebhookOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookOutput) } +func (i MutatingWebhookArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhook] { + return pulumix.Output[MutatingWebhook]{ + OutputState: i.ToMutatingWebhookOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookArrayInput is an input type that accepts MutatingWebhookArray and MutatingWebhookArrayOutput values. // You can construct a concrete instance of `MutatingWebhookArrayInput` via: // @@ -1700,6 +1899,12 @@ func (i MutatingWebhookArray) ToMutatingWebhookArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookArrayOutput) } +func (i MutatingWebhookArray) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhook] { + return pulumix.Output[[]MutatingWebhook]{ + OutputState: i.ToMutatingWebhookArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhook describes an admission webhook and the resources and operations it applies to. type MutatingWebhookOutput struct{ *pulumi.OutputState } @@ -1715,6 +1920,12 @@ func (o MutatingWebhookOutput) ToMutatingWebhookOutputWithContext(ctx context.Co return o } +func (o MutatingWebhookOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhook] { + return pulumix.Output[MutatingWebhook]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. Default to `['v1beta1']`. func (o MutatingWebhookOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v MutatingWebhook) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -1826,6 +2037,12 @@ func (o MutatingWebhookArrayOutput) ToMutatingWebhookArrayOutputWithContext(ctx return o } +func (o MutatingWebhookArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhook] { + return pulumix.Output[[]MutatingWebhook]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookArrayOutput) Index(i pulumi.IntInput) MutatingWebhookOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MutatingWebhook { return vs[0].([]MutatingWebhook)[vs[1].(int)] @@ -1879,6 +2096,12 @@ func (i MutatingWebhookConfigurationTypeArgs) ToMutatingWebhookConfigurationType return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationTypeOutput) } +func (i MutatingWebhookConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationType] { + return pulumix.Output[MutatingWebhookConfigurationType]{ + OutputState: i.ToMutatingWebhookConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationTypeArrayInput is an input type that accepts MutatingWebhookConfigurationTypeArray and MutatingWebhookConfigurationTypeArrayOutput values. // You can construct a concrete instance of `MutatingWebhookConfigurationTypeArrayInput` via: // @@ -1904,6 +2127,12 @@ func (i MutatingWebhookConfigurationTypeArray) ToMutatingWebhookConfigurationTyp return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationTypeArrayOutput) } +func (i MutatingWebhookConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookConfigurationType] { + return pulumix.Output[[]MutatingWebhookConfigurationType]{ + OutputState: i.ToMutatingWebhookConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 MutatingWebhookConfiguration instead. type MutatingWebhookConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -1919,6 +2148,12 @@ func (o MutatingWebhookConfigurationTypeOutput) ToMutatingWebhookConfigurationTy return o } +func (o MutatingWebhookConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationType] { + return pulumix.Output[MutatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v MutatingWebhookConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1953,6 +2188,12 @@ func (o MutatingWebhookConfigurationTypeArrayOutput) ToMutatingWebhookConfigurat return o } +func (o MutatingWebhookConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookConfigurationType] { + return pulumix.Output[[]MutatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookConfigurationTypeArrayOutput) Index(i pulumi.IntInput) MutatingWebhookConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MutatingWebhookConfigurationType { return vs[0].([]MutatingWebhookConfigurationType)[vs[1].(int)] @@ -2006,6 +2247,12 @@ func (i MutatingWebhookConfigurationListTypeArgs) ToMutatingWebhookConfiguration return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationListTypeOutput) } +func (i MutatingWebhookConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationListType] { + return pulumix.Output[MutatingWebhookConfigurationListType]{ + OutputState: i.ToMutatingWebhookConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. type MutatingWebhookConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -2021,6 +2268,12 @@ func (o MutatingWebhookConfigurationListTypeOutput) ToMutatingWebhookConfigurati return o } +func (o MutatingWebhookConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationListType] { + return pulumix.Output[MutatingWebhookConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v MutatingWebhookConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2088,6 +2341,12 @@ func (i MutatingWebhookConfigurationPatchTypeArgs) ToMutatingWebhookConfiguratio return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookConfigurationPatchTypeOutput) } +func (i MutatingWebhookConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationPatchType] { + return pulumix.Output[MutatingWebhookConfigurationPatchType]{ + OutputState: i.ToMutatingWebhookConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 MutatingWebhookConfiguration instead. type MutatingWebhookConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -2103,6 +2362,12 @@ func (o MutatingWebhookConfigurationPatchTypeOutput) ToMutatingWebhookConfigurat return o } +func (o MutatingWebhookConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookConfigurationPatchType] { + return pulumix.Output[MutatingWebhookConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o MutatingWebhookConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v MutatingWebhookConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2282,6 +2547,12 @@ func (i MutatingWebhookPatchArgs) ToMutatingWebhookPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookPatchOutput) } +func (i MutatingWebhookPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookPatch] { + return pulumix.Output[MutatingWebhookPatch]{ + OutputState: i.ToMutatingWebhookPatchOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhookPatchArrayInput is an input type that accepts MutatingWebhookPatchArray and MutatingWebhookPatchArrayOutput values. // You can construct a concrete instance of `MutatingWebhookPatchArrayInput` via: // @@ -2307,6 +2578,12 @@ func (i MutatingWebhookPatchArray) ToMutatingWebhookPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(MutatingWebhookPatchArrayOutput) } +func (i MutatingWebhookPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookPatch] { + return pulumix.Output[[]MutatingWebhookPatch]{ + OutputState: i.ToMutatingWebhookPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MutatingWebhook describes an admission webhook and the resources and operations it applies to. type MutatingWebhookPatchOutput struct{ *pulumi.OutputState } @@ -2322,6 +2599,12 @@ func (o MutatingWebhookPatchOutput) ToMutatingWebhookPatchOutputWithContext(ctx return o } +func (o MutatingWebhookPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MutatingWebhookPatch] { + return pulumix.Output[MutatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. Default to `['v1beta1']`. func (o MutatingWebhookPatchOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v MutatingWebhookPatch) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -2433,6 +2716,12 @@ func (o MutatingWebhookPatchArrayOutput) ToMutatingWebhookPatchArrayOutputWithCo return o } +func (o MutatingWebhookPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MutatingWebhookPatch] { + return pulumix.Output[[]MutatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + func (o MutatingWebhookPatchArrayOutput) Index(i pulumi.IntInput) MutatingWebhookPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MutatingWebhookPatch { return vs[0].([]MutatingWebhookPatch)[vs[1].(int)] @@ -2506,6 +2795,12 @@ func (i NamedRuleWithOperationsArgs) ToNamedRuleWithOperationsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsOutput) } +func (i NamedRuleWithOperationsArgs) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperations] { + return pulumix.Output[NamedRuleWithOperations]{ + OutputState: i.ToNamedRuleWithOperationsOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperationsArrayInput is an input type that accepts NamedRuleWithOperationsArray and NamedRuleWithOperationsArrayOutput values. // You can construct a concrete instance of `NamedRuleWithOperationsArrayInput` via: // @@ -2531,6 +2826,12 @@ func (i NamedRuleWithOperationsArray) ToNamedRuleWithOperationsArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsArrayOutput) } +func (i NamedRuleWithOperationsArray) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperations] { + return pulumix.Output[[]NamedRuleWithOperations]{ + OutputState: i.ToNamedRuleWithOperationsArrayOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperations is a tuple of Operations and Resources with ResourceNames. type NamedRuleWithOperationsOutput struct{ *pulumi.OutputState } @@ -2546,6 +2847,12 @@ func (o NamedRuleWithOperationsOutput) ToNamedRuleWithOperationsOutputWithContex return o } +func (o NamedRuleWithOperationsOutput) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperations] { + return pulumix.Output[NamedRuleWithOperations]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o NamedRuleWithOperationsOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v NamedRuleWithOperations) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -2596,6 +2903,12 @@ func (o NamedRuleWithOperationsArrayOutput) ToNamedRuleWithOperationsArrayOutput return o } +func (o NamedRuleWithOperationsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperations] { + return pulumix.Output[[]NamedRuleWithOperations]{ + OutputState: o.OutputState, + } +} + func (o NamedRuleWithOperationsArrayOutput) Index(i pulumi.IntInput) NamedRuleWithOperationsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamedRuleWithOperations { return vs[0].([]NamedRuleWithOperations)[vs[1].(int)] @@ -2669,6 +2982,12 @@ func (i NamedRuleWithOperationsPatchArgs) ToNamedRuleWithOperationsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsPatchOutput) } +func (i NamedRuleWithOperationsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperationsPatch] { + return pulumix.Output[NamedRuleWithOperationsPatch]{ + OutputState: i.ToNamedRuleWithOperationsPatchOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperationsPatchArrayInput is an input type that accepts NamedRuleWithOperationsPatchArray and NamedRuleWithOperationsPatchArrayOutput values. // You can construct a concrete instance of `NamedRuleWithOperationsPatchArrayInput` via: // @@ -2694,6 +3013,12 @@ func (i NamedRuleWithOperationsPatchArray) ToNamedRuleWithOperationsPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(NamedRuleWithOperationsPatchArrayOutput) } +func (i NamedRuleWithOperationsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperationsPatch] { + return pulumix.Output[[]NamedRuleWithOperationsPatch]{ + OutputState: i.ToNamedRuleWithOperationsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NamedRuleWithOperations is a tuple of Operations and Resources with ResourceNames. type NamedRuleWithOperationsPatchOutput struct{ *pulumi.OutputState } @@ -2709,6 +3034,12 @@ func (o NamedRuleWithOperationsPatchOutput) ToNamedRuleWithOperationsPatchOutput return o } +func (o NamedRuleWithOperationsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NamedRuleWithOperationsPatch] { + return pulumix.Output[NamedRuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o NamedRuleWithOperationsPatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v NamedRuleWithOperationsPatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -2759,6 +3090,12 @@ func (o NamedRuleWithOperationsPatchArrayOutput) ToNamedRuleWithOperationsPatchA return o } +func (o NamedRuleWithOperationsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamedRuleWithOperationsPatch] { + return pulumix.Output[[]NamedRuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + func (o NamedRuleWithOperationsPatchArrayOutput) Index(i pulumi.IntInput) NamedRuleWithOperationsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamedRuleWithOperationsPatch { return vs[0].([]NamedRuleWithOperationsPatch)[vs[1].(int)] @@ -2804,6 +3141,12 @@ func (i ParamKindArgs) ToParamKindOutputWithContext(ctx context.Context) ParamKi return pulumi.ToOutputWithContext(ctx, i).(ParamKindOutput) } +func (i ParamKindArgs) ToOutput(ctx context.Context) pulumix.Output[ParamKind] { + return pulumix.Output[ParamKind]{ + OutputState: i.ToParamKindOutputWithContext(ctx).OutputState, + } +} + func (i ParamKindArgs) ToParamKindPtrOutput() ParamKindPtrOutput { return i.ToParamKindPtrOutputWithContext(context.Background()) } @@ -2845,6 +3188,12 @@ func (i *paramKindPtrType) ToParamKindPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ParamKindPtrOutput) } +func (i *paramKindPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamKind] { + return pulumix.Output[*ParamKind]{ + OutputState: i.ToParamKindPtrOutputWithContext(ctx).OutputState, + } +} + // ParamKind is a tuple of Group Kind and Version. type ParamKindOutput struct{ *pulumi.OutputState } @@ -2870,6 +3219,12 @@ func (o ParamKindOutput) ToParamKindPtrOutputWithContext(ctx context.Context) Pa }).(ParamKindPtrOutput) } +func (o ParamKindOutput) ToOutput(ctx context.Context) pulumix.Output[ParamKind] { + return pulumix.Output[ParamKind]{ + OutputState: o.OutputState, + } +} + // APIVersion is the API group version the resources belong to. In format of "group/version". Required. func (o ParamKindOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ParamKind) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2894,6 +3249,12 @@ func (o ParamKindPtrOutput) ToParamKindPtrOutputWithContext(ctx context.Context) return o } +func (o ParamKindPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamKind] { + return pulumix.Output[*ParamKind]{ + OutputState: o.OutputState, + } +} + func (o ParamKindPtrOutput) Elem() ParamKindOutput { return o.ApplyT(func(v *ParamKind) ParamKind { if v != nil { @@ -2963,6 +3324,12 @@ func (i ParamKindPatchArgs) ToParamKindPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ParamKindPatchOutput) } +func (i ParamKindPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ParamKindPatch] { + return pulumix.Output[ParamKindPatch]{ + OutputState: i.ToParamKindPatchOutputWithContext(ctx).OutputState, + } +} + func (i ParamKindPatchArgs) ToParamKindPatchPtrOutput() ParamKindPatchPtrOutput { return i.ToParamKindPatchPtrOutputWithContext(context.Background()) } @@ -3004,6 +3371,12 @@ func (i *paramKindPatchPtrType) ToParamKindPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ParamKindPatchPtrOutput) } +func (i *paramKindPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamKindPatch] { + return pulumix.Output[*ParamKindPatch]{ + OutputState: i.ToParamKindPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ParamKind is a tuple of Group Kind and Version. type ParamKindPatchOutput struct{ *pulumi.OutputState } @@ -3029,6 +3402,12 @@ func (o ParamKindPatchOutput) ToParamKindPatchPtrOutputWithContext(ctx context.C }).(ParamKindPatchPtrOutput) } +func (o ParamKindPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ParamKindPatch] { + return pulumix.Output[ParamKindPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion is the API group version the resources belong to. In format of "group/version". Required. func (o ParamKindPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ParamKindPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3053,6 +3432,12 @@ func (o ParamKindPatchPtrOutput) ToParamKindPatchPtrOutputWithContext(ctx contex return o } +func (o ParamKindPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamKindPatch] { + return pulumix.Output[*ParamKindPatch]{ + OutputState: o.OutputState, + } +} + func (o ParamKindPatchPtrOutput) Elem() ParamKindPatchOutput { return o.ApplyT(func(v *ParamKindPatch) ParamKindPatch { if v != nil { @@ -3166,6 +3551,12 @@ func (i ParamRefArgs) ToParamRefOutputWithContext(ctx context.Context) ParamRefO return pulumi.ToOutputWithContext(ctx, i).(ParamRefOutput) } +func (i ParamRefArgs) ToOutput(ctx context.Context) pulumix.Output[ParamRef] { + return pulumix.Output[ParamRef]{ + OutputState: i.ToParamRefOutputWithContext(ctx).OutputState, + } +} + func (i ParamRefArgs) ToParamRefPtrOutput() ParamRefPtrOutput { return i.ToParamRefPtrOutputWithContext(context.Background()) } @@ -3207,6 +3598,12 @@ func (i *paramRefPtrType) ToParamRefPtrOutputWithContext(ctx context.Context) Pa return pulumi.ToOutputWithContext(ctx, i).(ParamRefPtrOutput) } +func (i *paramRefPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamRef] { + return pulumix.Output[*ParamRef]{ + OutputState: i.ToParamRefPtrOutputWithContext(ctx).OutputState, + } +} + // ParamRef describes how to locate the params to be used as input to expressions of rules applied by a policy binding. type ParamRefOutput struct{ *pulumi.OutputState } @@ -3232,6 +3629,12 @@ func (o ParamRefOutput) ToParamRefPtrOutputWithContext(ctx context.Context) Para }).(ParamRefPtrOutput) } +func (o ParamRefOutput) ToOutput(ctx context.Context) pulumix.Output[ParamRef] { + return pulumix.Output[ParamRef]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource being referenced. // // One of `name` or `selector` must be set, but `name` and `selector` are mutually exclusive properties. If one is set, the other must be unset. @@ -3284,6 +3687,12 @@ func (o ParamRefPtrOutput) ToParamRefPtrOutputWithContext(ctx context.Context) P return o } +func (o ParamRefPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamRef] { + return pulumix.Output[*ParamRef]{ + OutputState: o.OutputState, + } +} + func (o ParamRefPtrOutput) Elem() ParamRefOutput { return o.ApplyT(func(v *ParamRef) ParamRef { if v != nil { @@ -3435,6 +3844,12 @@ func (i ParamRefPatchArgs) ToParamRefPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ParamRefPatchOutput) } +func (i ParamRefPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ParamRefPatch] { + return pulumix.Output[ParamRefPatch]{ + OutputState: i.ToParamRefPatchOutputWithContext(ctx).OutputState, + } +} + func (i ParamRefPatchArgs) ToParamRefPatchPtrOutput() ParamRefPatchPtrOutput { return i.ToParamRefPatchPtrOutputWithContext(context.Background()) } @@ -3476,6 +3891,12 @@ func (i *paramRefPatchPtrType) ToParamRefPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ParamRefPatchPtrOutput) } +func (i *paramRefPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParamRefPatch] { + return pulumix.Output[*ParamRefPatch]{ + OutputState: i.ToParamRefPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ParamRef describes how to locate the params to be used as input to expressions of rules applied by a policy binding. type ParamRefPatchOutput struct{ *pulumi.OutputState } @@ -3501,6 +3922,12 @@ func (o ParamRefPatchOutput) ToParamRefPatchPtrOutputWithContext(ctx context.Con }).(ParamRefPatchPtrOutput) } +func (o ParamRefPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ParamRefPatch] { + return pulumix.Output[ParamRefPatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource being referenced. // // One of `name` or `selector` must be set, but `name` and `selector` are mutually exclusive properties. If one is set, the other must be unset. @@ -3553,6 +3980,12 @@ func (o ParamRefPatchPtrOutput) ToParamRefPatchPtrOutputWithContext(ctx context. return o } +func (o ParamRefPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParamRefPatch] { + return pulumix.Output[*ParamRefPatch]{ + OutputState: o.OutputState, + } +} + func (o ParamRefPatchPtrOutput) Elem() ParamRefPatchOutput { return o.ApplyT(func(v *ParamRefPatch) ParamRefPatch { if v != nil { @@ -3684,6 +4117,12 @@ func (i RuleWithOperationsArgs) ToRuleWithOperationsOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsOutput) } +func (i RuleWithOperationsArgs) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperations] { + return pulumix.Output[RuleWithOperations]{ + OutputState: i.ToRuleWithOperationsOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperationsArrayInput is an input type that accepts RuleWithOperationsArray and RuleWithOperationsArrayOutput values. // You can construct a concrete instance of `RuleWithOperationsArrayInput` via: // @@ -3709,6 +4148,12 @@ func (i RuleWithOperationsArray) ToRuleWithOperationsArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsArrayOutput) } +func (i RuleWithOperationsArray) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperations] { + return pulumix.Output[[]RuleWithOperations]{ + OutputState: i.ToRuleWithOperationsArrayOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. type RuleWithOperationsOutput struct{ *pulumi.OutputState } @@ -3724,6 +4169,12 @@ func (o RuleWithOperationsOutput) ToRuleWithOperationsOutputWithContext(ctx cont return o } +func (o RuleWithOperationsOutput) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperations] { + return pulumix.Output[RuleWithOperations]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o RuleWithOperationsOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v RuleWithOperations) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -3769,6 +4220,12 @@ func (o RuleWithOperationsArrayOutput) ToRuleWithOperationsArrayOutputWithContex return o } +func (o RuleWithOperationsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperations] { + return pulumix.Output[[]RuleWithOperations]{ + OutputState: o.OutputState, + } +} + func (o RuleWithOperationsArrayOutput) Index(i pulumi.IntInput) RuleWithOperationsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuleWithOperations { return vs[0].([]RuleWithOperations)[vs[1].(int)] @@ -3838,6 +4295,12 @@ func (i RuleWithOperationsPatchArgs) ToRuleWithOperationsPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsPatchOutput) } +func (i RuleWithOperationsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperationsPatch] { + return pulumix.Output[RuleWithOperationsPatch]{ + OutputState: i.ToRuleWithOperationsPatchOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperationsPatchArrayInput is an input type that accepts RuleWithOperationsPatchArray and RuleWithOperationsPatchArrayOutput values. // You can construct a concrete instance of `RuleWithOperationsPatchArrayInput` via: // @@ -3863,6 +4326,12 @@ func (i RuleWithOperationsPatchArray) ToRuleWithOperationsPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(RuleWithOperationsPatchArrayOutput) } +func (i RuleWithOperationsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperationsPatch] { + return pulumix.Output[[]RuleWithOperationsPatch]{ + OutputState: i.ToRuleWithOperationsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. type RuleWithOperationsPatchOutput struct{ *pulumi.OutputState } @@ -3878,6 +4347,12 @@ func (o RuleWithOperationsPatchOutput) ToRuleWithOperationsPatchOutputWithContex return o } +func (o RuleWithOperationsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RuleWithOperationsPatch] { + return pulumix.Output[RuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. func (o RuleWithOperationsPatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v RuleWithOperationsPatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -3923,6 +4398,12 @@ func (o RuleWithOperationsPatchArrayOutput) ToRuleWithOperationsPatchArrayOutput return o } +func (o RuleWithOperationsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuleWithOperationsPatch] { + return pulumix.Output[[]RuleWithOperationsPatch]{ + OutputState: o.OutputState, + } +} + func (o RuleWithOperationsPatchArrayOutput) Index(i pulumi.IntInput) RuleWithOperationsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuleWithOperationsPatch { return vs[0].([]RuleWithOperationsPatch)[vs[1].(int)] @@ -3976,6 +4457,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -4017,6 +4504,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -4042,6 +4535,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the service. Required func (o ServiceReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceReference) string { return v.Name }).(pulumi.StringOutput) @@ -4076,6 +4575,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -4173,6 +4678,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -4214,6 +4725,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -4239,6 +4756,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the service. Required func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -4273,6 +4796,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { @@ -4358,6 +4887,12 @@ func (i TypeCheckingArgs) ToTypeCheckingOutputWithContext(ctx context.Context) T return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingOutput) } +func (i TypeCheckingArgs) ToOutput(ctx context.Context) pulumix.Output[TypeChecking] { + return pulumix.Output[TypeChecking]{ + OutputState: i.ToTypeCheckingOutputWithContext(ctx).OutputState, + } +} + func (i TypeCheckingArgs) ToTypeCheckingPtrOutput() TypeCheckingPtrOutput { return i.ToTypeCheckingPtrOutputWithContext(context.Background()) } @@ -4399,6 +4934,12 @@ func (i *typeCheckingPtrType) ToTypeCheckingPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingPtrOutput) } +func (i *typeCheckingPtrType) ToOutput(ctx context.Context) pulumix.Output[*TypeChecking] { + return pulumix.Output[*TypeChecking]{ + OutputState: i.ToTypeCheckingPtrOutputWithContext(ctx).OutputState, + } +} + // TypeChecking contains results of type checking the expressions in the ValidatingAdmissionPolicy type TypeCheckingOutput struct{ *pulumi.OutputState } @@ -4424,6 +4965,12 @@ func (o TypeCheckingOutput) ToTypeCheckingPtrOutputWithContext(ctx context.Conte }).(TypeCheckingPtrOutput) } +func (o TypeCheckingOutput) ToOutput(ctx context.Context) pulumix.Output[TypeChecking] { + return pulumix.Output[TypeChecking]{ + OutputState: o.OutputState, + } +} + // The type checking warnings for each expression. func (o TypeCheckingOutput) ExpressionWarnings() ExpressionWarningArrayOutput { return o.ApplyT(func(v TypeChecking) []ExpressionWarning { return v.ExpressionWarnings }).(ExpressionWarningArrayOutput) @@ -4443,6 +4990,12 @@ func (o TypeCheckingPtrOutput) ToTypeCheckingPtrOutputWithContext(ctx context.Co return o } +func (o TypeCheckingPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypeChecking] { + return pulumix.Output[*TypeChecking]{ + OutputState: o.OutputState, + } +} + func (o TypeCheckingPtrOutput) Elem() TypeCheckingOutput { return o.ApplyT(func(v *TypeChecking) TypeChecking { if v != nil { @@ -4498,6 +5051,12 @@ func (i TypeCheckingPatchArgs) ToTypeCheckingPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingPatchOutput) } +func (i TypeCheckingPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TypeCheckingPatch] { + return pulumix.Output[TypeCheckingPatch]{ + OutputState: i.ToTypeCheckingPatchOutputWithContext(ctx).OutputState, + } +} + func (i TypeCheckingPatchArgs) ToTypeCheckingPatchPtrOutput() TypeCheckingPatchPtrOutput { return i.ToTypeCheckingPatchPtrOutputWithContext(context.Background()) } @@ -4539,6 +5098,12 @@ func (i *typeCheckingPatchPtrType) ToTypeCheckingPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(TypeCheckingPatchPtrOutput) } +func (i *typeCheckingPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TypeCheckingPatch] { + return pulumix.Output[*TypeCheckingPatch]{ + OutputState: i.ToTypeCheckingPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TypeChecking contains results of type checking the expressions in the ValidatingAdmissionPolicy type TypeCheckingPatchOutput struct{ *pulumi.OutputState } @@ -4564,6 +5129,12 @@ func (o TypeCheckingPatchOutput) ToTypeCheckingPatchPtrOutputWithContext(ctx con }).(TypeCheckingPatchPtrOutput) } +func (o TypeCheckingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TypeCheckingPatch] { + return pulumix.Output[TypeCheckingPatch]{ + OutputState: o.OutputState, + } +} + // The type checking warnings for each expression. func (o TypeCheckingPatchOutput) ExpressionWarnings() ExpressionWarningPatchArrayOutput { return o.ApplyT(func(v TypeCheckingPatch) []ExpressionWarningPatch { return v.ExpressionWarnings }).(ExpressionWarningPatchArrayOutput) @@ -4583,6 +5154,12 @@ func (o TypeCheckingPatchPtrOutput) ToTypeCheckingPatchPtrOutputWithContext(ctx return o } +func (o TypeCheckingPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypeCheckingPatch] { + return pulumix.Output[*TypeCheckingPatch]{ + OutputState: o.OutputState, + } +} + func (o TypeCheckingPatchPtrOutput) Elem() TypeCheckingPatchOutput { return o.ApplyT(func(v *TypeCheckingPatch) TypeCheckingPatch { if v != nil { @@ -4654,6 +5231,12 @@ func (i ValidatingAdmissionPolicyTypeArgs) ToValidatingAdmissionPolicyTypeOutput return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyTypeOutput) } +func (i ValidatingAdmissionPolicyTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyType] { + return pulumix.Output[ValidatingAdmissionPolicyType]{ + OutputState: i.ToValidatingAdmissionPolicyTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyTypeArrayInput is an input type that accepts ValidatingAdmissionPolicyTypeArray and ValidatingAdmissionPolicyTypeArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyTypeArrayInput` via: // @@ -4679,6 +5262,12 @@ func (i ValidatingAdmissionPolicyTypeArray) ToValidatingAdmissionPolicyTypeArray return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyTypeArrayOutput) } +func (i ValidatingAdmissionPolicyTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyType] { + return pulumix.Output[[]ValidatingAdmissionPolicyType]{ + OutputState: i.ToValidatingAdmissionPolicyTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicy describes the definition of an admission validation policy that accepts or rejects an object without changing it. type ValidatingAdmissionPolicyTypeOutput struct{ *pulumi.OutputState } @@ -4694,6 +5283,12 @@ func (o ValidatingAdmissionPolicyTypeOutput) ToValidatingAdmissionPolicyTypeOutp return o } +func (o ValidatingAdmissionPolicyTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyType] { + return pulumix.Output[ValidatingAdmissionPolicyType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4733,6 +5328,12 @@ func (o ValidatingAdmissionPolicyTypeArrayOutput) ToValidatingAdmissionPolicyTyp return o } +func (o ValidatingAdmissionPolicyTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyType] { + return pulumix.Output[[]ValidatingAdmissionPolicyType]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyTypeArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingAdmissionPolicyType { return vs[0].([]ValidatingAdmissionPolicyType)[vs[1].(int)] @@ -4794,6 +5395,12 @@ func (i ValidatingAdmissionPolicyBindingTypeArgs) ToValidatingAdmissionPolicyBin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingTypeOutput) } +func (i ValidatingAdmissionPolicyBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingTypeArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingTypeArray and ValidatingAdmissionPolicyBindingTypeArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingTypeArrayInput` via: // @@ -4819,6 +5426,12 @@ func (i ValidatingAdmissionPolicyBindingTypeArray) ToValidatingAdmissionPolicyBi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingTypeArrayOutput) } +func (i ValidatingAdmissionPolicyBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[[]ValidatingAdmissionPolicyBindingType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBinding binds the ValidatingAdmissionPolicy with paramerized resources. ValidatingAdmissionPolicyBinding and parameter CRDs together define how cluster administrators configure policies for clusters. // // For a given admission request, each binding will cause its policy to be evaluated N times, where N is 1 for policies/bindings that don't use params, otherwise N is the number of parameters selected by the binding. @@ -4838,6 +5451,12 @@ func (o ValidatingAdmissionPolicyBindingTypeOutput) ToValidatingAdmissionPolicyB return o } +func (o ValidatingAdmissionPolicyBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4872,6 +5491,12 @@ func (o ValidatingAdmissionPolicyBindingTypeArrayOutput) ToValidatingAdmissionPo return o } +func (o ValidatingAdmissionPolicyBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingAdmissionPolicyBindingType] { + return pulumix.Output[[]ValidatingAdmissionPolicyBindingType]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingTypeArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingAdmissionPolicyBindingType { return vs[0].([]ValidatingAdmissionPolicyBindingType)[vs[1].(int)] @@ -4925,6 +5550,12 @@ func (i ValidatingAdmissionPolicyBindingListTypeArgs) ToValidatingAdmissionPolic return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListTypeOutput) } +func (i ValidatingAdmissionPolicyBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingListType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingListType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingList is a list of ValidatingAdmissionPolicyBinding. type ValidatingAdmissionPolicyBindingListTypeOutput struct{ *pulumi.OutputState } @@ -4940,6 +5571,12 @@ func (o ValidatingAdmissionPolicyBindingListTypeOutput) ToValidatingAdmissionPol return o } +func (o ValidatingAdmissionPolicyBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingListType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5017,6 +5654,12 @@ func (i ValidatingAdmissionPolicyBindingPatchTypeArgs) ToValidatingAdmissionPoli return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchTypeOutput) } +func (i ValidatingAdmissionPolicyBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingPatchType]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBinding binds the ValidatingAdmissionPolicy with paramerized resources. ValidatingAdmissionPolicyBinding and parameter CRDs together define how cluster administrators configure policies for clusters. // // For a given admission request, each binding will cause its policy to be evaluated N times, where N is 1 for policies/bindings that don't use params, otherwise N is the number of parameters selected by the binding. @@ -5036,6 +5679,12 @@ func (o ValidatingAdmissionPolicyBindingPatchTypeOutput) ToValidatingAdmissionPo return o } +func (o ValidatingAdmissionPolicyBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5141,6 +5790,12 @@ func (i ValidatingAdmissionPolicyBindingSpecArgs) ToValidatingAdmissionPolicyBin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecOutput) } +func (i ValidatingAdmissionPolicyBindingSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpec]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyBindingSpecArgs) ToValidatingAdmissionPolicyBindingSpecPtrOutput() ValidatingAdmissionPolicyBindingSpecPtrOutput { return i.ToValidatingAdmissionPolicyBindingSpecPtrOutputWithContext(context.Background()) } @@ -5182,6 +5837,12 @@ func (i *validatingAdmissionPolicyBindingSpecPtrType) ToValidatingAdmissionPolic return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecPtrOutput) } +func (i *validatingAdmissionPolicyBindingSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpec]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingSpec is the specification of the ValidatingAdmissionPolicyBinding. type ValidatingAdmissionPolicyBindingSpecOutput struct{ *pulumi.OutputState } @@ -5207,6 +5868,12 @@ func (o ValidatingAdmissionPolicyBindingSpecOutput) ToValidatingAdmissionPolicyB }).(ValidatingAdmissionPolicyBindingSpecPtrOutput) } +func (o ValidatingAdmissionPolicyBindingSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpec]{ + OutputState: o.OutputState, + } +} + // MatchResources declares what resources match this binding and will be validated by it. Note that this is intersected with the policy's matchConstraints, so only requests that are matched by the policy can be selected by this. If this is unset, all resources matched by the policy are validated by this binding When resourceRules is unset, it does not constrain resource matching. If a resource is matched by the other fields of this object, it will be validated. Note that this is differs from ValidatingAdmissionPolicy matchConstraints, where resourceRules are required. func (o ValidatingAdmissionPolicyBindingSpecOutput) MatchResources() MatchResourcesPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingSpec) *MatchResources { return v.MatchResources }).(MatchResourcesPtrOutput) @@ -5259,6 +5926,12 @@ func (o ValidatingAdmissionPolicyBindingSpecPtrOutput) ToValidatingAdmissionPoli return o } +func (o ValidatingAdmissionPolicyBindingSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpec] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpec]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingSpecPtrOutput) Elem() ValidatingAdmissionPolicyBindingSpecOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingSpec) ValidatingAdmissionPolicyBindingSpec { if v != nil { @@ -5410,6 +6083,12 @@ func (i ValidatingAdmissionPolicyBindingSpecPatchArgs) ToValidatingAdmissionPoli return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecPatchOutput) } +func (i ValidatingAdmissionPolicyBindingSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyBindingSpecPatchArgs) ToValidatingAdmissionPolicyBindingSpecPatchPtrOutput() ValidatingAdmissionPolicyBindingSpecPatchPtrOutput { return i.ToValidatingAdmissionPolicyBindingSpecPatchPtrOutputWithContext(context.Background()) } @@ -5451,6 +6130,12 @@ func (i *validatingAdmissionPolicyBindingSpecPatchPtrType) ToValidatingAdmission return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) } +func (i *validatingAdmissionPolicyBindingSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingSpec is the specification of the ValidatingAdmissionPolicyBinding. type ValidatingAdmissionPolicyBindingSpecPatchOutput struct{ *pulumi.OutputState } @@ -5476,6 +6161,12 @@ func (o ValidatingAdmissionPolicyBindingSpecPatchOutput) ToValidatingAdmissionPo }).(ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) } +func (o ValidatingAdmissionPolicyBindingSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: o.OutputState, + } +} + // MatchResources declares what resources match this binding and will be validated by it. Note that this is intersected with the policy's matchConstraints, so only requests that are matched by the policy can be selected by this. If this is unset, all resources matched by the policy are validated by this binding When resourceRules is unset, it does not constrain resource matching. If a resource is matched by the other fields of this object, it will be validated. Note that this is differs from ValidatingAdmissionPolicy matchConstraints, where resourceRules are required. func (o ValidatingAdmissionPolicyBindingSpecPatchOutput) MatchResources() MatchResourcesPatchPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyBindingSpecPatch) *MatchResourcesPatch { return v.MatchResources }).(MatchResourcesPatchPtrOutput) @@ -5528,6 +6219,12 @@ func (o ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) ToValidatingAdmissio return o } +func (o ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingSpecPatchPtrOutput) Elem() ValidatingAdmissionPolicyBindingSpecPatchOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingSpecPatch) ValidatingAdmissionPolicyBindingSpecPatch { if v != nil { @@ -5643,6 +6340,12 @@ func (i ValidatingAdmissionPolicyListTypeArgs) ToValidatingAdmissionPolicyListTy return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListTypeOutput) } +func (i ValidatingAdmissionPolicyListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyListType] { + return pulumix.Output[ValidatingAdmissionPolicyListType]{ + OutputState: i.ToValidatingAdmissionPolicyListTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyList is a list of ValidatingAdmissionPolicy. type ValidatingAdmissionPolicyListTypeOutput struct{ *pulumi.OutputState } @@ -5658,6 +6361,12 @@ func (o ValidatingAdmissionPolicyListTypeOutput) ToValidatingAdmissionPolicyList return o } +func (o ValidatingAdmissionPolicyListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyListType] { + return pulumix.Output[ValidatingAdmissionPolicyListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5729,6 +6438,12 @@ func (i ValidatingAdmissionPolicyPatchTypeArgs) ToValidatingAdmissionPolicyPatch return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchTypeOutput) } +func (i ValidatingAdmissionPolicyPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyPatchType]{ + OutputState: i.ToValidatingAdmissionPolicyPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicy describes the definition of an admission validation policy that accepts or rejects an object without changing it. type ValidatingAdmissionPolicyPatchTypeOutput struct{ *pulumi.OutputState } @@ -5744,6 +6459,12 @@ func (o ValidatingAdmissionPolicyPatchTypeOutput) ToValidatingAdmissionPolicyPat return o } +func (o ValidatingAdmissionPolicyPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyPatchType] { + return pulumix.Output[ValidatingAdmissionPolicyPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5866,6 +6587,12 @@ func (i ValidatingAdmissionPolicySpecArgs) ToValidatingAdmissionPolicySpecOutput return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecOutput) } +func (i ValidatingAdmissionPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpec] { + return pulumix.Output[ValidatingAdmissionPolicySpec]{ + OutputState: i.ToValidatingAdmissionPolicySpecOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicySpecArgs) ToValidatingAdmissionPolicySpecPtrOutput() ValidatingAdmissionPolicySpecPtrOutput { return i.ToValidatingAdmissionPolicySpecPtrOutputWithContext(context.Background()) } @@ -5907,6 +6634,12 @@ func (i *validatingAdmissionPolicySpecPtrType) ToValidatingAdmissionPolicySpecPt return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecPtrOutput) } +func (i *validatingAdmissionPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpec] { + return pulumix.Output[*ValidatingAdmissionPolicySpec]{ + OutputState: i.ToValidatingAdmissionPolicySpecPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicySpec is the specification of the desired behavior of the AdmissionPolicy. type ValidatingAdmissionPolicySpecOutput struct{ *pulumi.OutputState } @@ -5932,6 +6665,12 @@ func (o ValidatingAdmissionPolicySpecOutput) ToValidatingAdmissionPolicySpecPtrO }).(ValidatingAdmissionPolicySpecPtrOutput) } +func (o ValidatingAdmissionPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpec] { + return pulumix.Output[ValidatingAdmissionPolicySpec]{ + OutputState: o.OutputState, + } +} + // auditAnnotations contains CEL expressions which are used to produce audit annotations for the audit event of the API request. validations and auditAnnotations may not both be empty; a least one of validations or auditAnnotations is required. func (o ValidatingAdmissionPolicySpecOutput) AuditAnnotations() AuditAnnotationArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicySpec) []AuditAnnotation { return v.AuditAnnotations }).(AuditAnnotationArrayOutput) @@ -6000,6 +6739,12 @@ func (o ValidatingAdmissionPolicySpecPtrOutput) ToValidatingAdmissionPolicySpecP return o } +func (o ValidatingAdmissionPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpec] { + return pulumix.Output[*ValidatingAdmissionPolicySpec]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicySpecPtrOutput) Elem() ValidatingAdmissionPolicySpecOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicySpec) ValidatingAdmissionPolicySpec { if v != nil { @@ -6196,6 +6941,12 @@ func (i ValidatingAdmissionPolicySpecPatchArgs) ToValidatingAdmissionPolicySpecP return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecPatchOutput) } +func (i ValidatingAdmissionPolicySpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicySpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicySpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicySpecPatchArgs) ToValidatingAdmissionPolicySpecPatchPtrOutput() ValidatingAdmissionPolicySpecPatchPtrOutput { return i.ToValidatingAdmissionPolicySpecPatchPtrOutputWithContext(context.Background()) } @@ -6237,6 +6988,12 @@ func (i *validatingAdmissionPolicySpecPatchPtrType) ToValidatingAdmissionPolicyS return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicySpecPatchPtrOutput) } +func (i *validatingAdmissionPolicySpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicySpecPatch]{ + OutputState: i.ToValidatingAdmissionPolicySpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicySpec is the specification of the desired behavior of the AdmissionPolicy. type ValidatingAdmissionPolicySpecPatchOutput struct{ *pulumi.OutputState } @@ -6262,6 +7019,12 @@ func (o ValidatingAdmissionPolicySpecPatchOutput) ToValidatingAdmissionPolicySpe }).(ValidatingAdmissionPolicySpecPatchPtrOutput) } +func (o ValidatingAdmissionPolicySpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[ValidatingAdmissionPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + // auditAnnotations contains CEL expressions which are used to produce audit annotations for the audit event of the API request. validations and auditAnnotations may not both be empty; a least one of validations or auditAnnotations is required. func (o ValidatingAdmissionPolicySpecPatchOutput) AuditAnnotations() AuditAnnotationPatchArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicySpecPatch) []AuditAnnotationPatch { return v.AuditAnnotations }).(AuditAnnotationPatchArrayOutput) @@ -6330,6 +7093,12 @@ func (o ValidatingAdmissionPolicySpecPatchPtrOutput) ToValidatingAdmissionPolicy return o } +func (o ValidatingAdmissionPolicySpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicySpecPatch] { + return pulumix.Output[*ValidatingAdmissionPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicySpecPatchPtrOutput) Elem() ValidatingAdmissionPolicySpecPatchOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicySpecPatch) ValidatingAdmissionPolicySpecPatch { if v != nil { @@ -6472,6 +7241,12 @@ func (i ValidatingAdmissionPolicyStatusArgs) ToValidatingAdmissionPolicyStatusOu return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusOutput) } +func (i ValidatingAdmissionPolicyStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatus] { + return pulumix.Output[ValidatingAdmissionPolicyStatus]{ + OutputState: i.ToValidatingAdmissionPolicyStatusOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyStatusArgs) ToValidatingAdmissionPolicyStatusPtrOutput() ValidatingAdmissionPolicyStatusPtrOutput { return i.ToValidatingAdmissionPolicyStatusPtrOutputWithContext(context.Background()) } @@ -6513,6 +7288,12 @@ func (i *validatingAdmissionPolicyStatusPtrType) ToValidatingAdmissionPolicyStat return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusPtrOutput) } +func (i *validatingAdmissionPolicyStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatus] { + return pulumix.Output[*ValidatingAdmissionPolicyStatus]{ + OutputState: i.ToValidatingAdmissionPolicyStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyStatus represents the status of an admission validation policy. type ValidatingAdmissionPolicyStatusOutput struct{ *pulumi.OutputState } @@ -6538,6 +7319,12 @@ func (o ValidatingAdmissionPolicyStatusOutput) ToValidatingAdmissionPolicyStatus }).(ValidatingAdmissionPolicyStatusPtrOutput) } +func (o ValidatingAdmissionPolicyStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatus] { + return pulumix.Output[ValidatingAdmissionPolicyStatus]{ + OutputState: o.OutputState, + } +} + // The conditions represent the latest available observations of a policy's current state. func (o ValidatingAdmissionPolicyStatusOutput) Conditions() metav1.ConditionArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyStatus) []metav1.Condition { return v.Conditions }).(metav1.ConditionArrayOutput) @@ -6567,6 +7354,12 @@ func (o ValidatingAdmissionPolicyStatusPtrOutput) ToValidatingAdmissionPolicySta return o } +func (o ValidatingAdmissionPolicyStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatus] { + return pulumix.Output[*ValidatingAdmissionPolicyStatus]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyStatusPtrOutput) Elem() ValidatingAdmissionPolicyStatusOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyStatus) ValidatingAdmissionPolicyStatus { if v != nil { @@ -6650,6 +7443,12 @@ func (i ValidatingAdmissionPolicyStatusPatchArgs) ToValidatingAdmissionPolicySta return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusPatchOutput) } +func (i ValidatingAdmissionPolicyStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[ValidatingAdmissionPolicyStatusPatch]{ + OutputState: i.ToValidatingAdmissionPolicyStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ValidatingAdmissionPolicyStatusPatchArgs) ToValidatingAdmissionPolicyStatusPatchPtrOutput() ValidatingAdmissionPolicyStatusPatchPtrOutput { return i.ToValidatingAdmissionPolicyStatusPatchPtrOutputWithContext(context.Background()) } @@ -6691,6 +7490,12 @@ func (i *validatingAdmissionPolicyStatusPatchPtrType) ToValidatingAdmissionPolic return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyStatusPatchPtrOutput) } +func (i *validatingAdmissionPolicyStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyStatusPatch]{ + OutputState: i.ToValidatingAdmissionPolicyStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyStatus represents the status of an admission validation policy. type ValidatingAdmissionPolicyStatusPatchOutput struct{ *pulumi.OutputState } @@ -6716,6 +7521,12 @@ func (o ValidatingAdmissionPolicyStatusPatchOutput) ToValidatingAdmissionPolicyS }).(ValidatingAdmissionPolicyStatusPatchPtrOutput) } +func (o ValidatingAdmissionPolicyStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[ValidatingAdmissionPolicyStatusPatch]{ + OutputState: o.OutputState, + } +} + // The conditions represent the latest available observations of a policy's current state. func (o ValidatingAdmissionPolicyStatusPatchOutput) Conditions() metav1.ConditionPatchArrayOutput { return o.ApplyT(func(v ValidatingAdmissionPolicyStatusPatch) []metav1.ConditionPatch { return v.Conditions }).(metav1.ConditionPatchArrayOutput) @@ -6745,6 +7556,12 @@ func (o ValidatingAdmissionPolicyStatusPatchPtrOutput) ToValidatingAdmissionPoli return o } +func (o ValidatingAdmissionPolicyStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyStatusPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyStatusPatchPtrOutput) Elem() ValidatingAdmissionPolicyStatusPatchOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyStatusPatch) ValidatingAdmissionPolicyStatusPatch { if v != nil { @@ -6928,6 +7745,12 @@ func (i ValidatingWebhookArgs) ToValidatingWebhookOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookOutput) } +func (i ValidatingWebhookArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhook] { + return pulumix.Output[ValidatingWebhook]{ + OutputState: i.ToValidatingWebhookOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookArrayInput is an input type that accepts ValidatingWebhookArray and ValidatingWebhookArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookArrayInput` via: // @@ -6953,6 +7776,12 @@ func (i ValidatingWebhookArray) ToValidatingWebhookArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookArrayOutput) } +func (i ValidatingWebhookArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhook] { + return pulumix.Output[[]ValidatingWebhook]{ + OutputState: i.ToValidatingWebhookArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhook describes an admission webhook and the resources and operations it applies to. type ValidatingWebhookOutput struct{ *pulumi.OutputState } @@ -6968,6 +7797,12 @@ func (o ValidatingWebhookOutput) ToValidatingWebhookOutputWithContext(ctx contex return o } +func (o ValidatingWebhookOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhook] { + return pulumix.Output[ValidatingWebhook]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. Default to `['v1beta1']`. func (o ValidatingWebhookOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v ValidatingWebhook) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -7068,6 +7903,12 @@ func (o ValidatingWebhookArrayOutput) ToValidatingWebhookArrayOutputWithContext( return o } +func (o ValidatingWebhookArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhook] { + return pulumix.Output[[]ValidatingWebhook]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingWebhook { return vs[0].([]ValidatingWebhook)[vs[1].(int)] @@ -7121,6 +7962,12 @@ func (i ValidatingWebhookConfigurationTypeArgs) ToValidatingWebhookConfiguration return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationTypeOutput) } +func (i ValidatingWebhookConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationType] { + return pulumix.Output[ValidatingWebhookConfigurationType]{ + OutputState: i.ToValidatingWebhookConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationTypeArrayInput is an input type that accepts ValidatingWebhookConfigurationTypeArray and ValidatingWebhookConfigurationTypeArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationTypeArrayInput` via: // @@ -7146,6 +7993,12 @@ func (i ValidatingWebhookConfigurationTypeArray) ToValidatingWebhookConfiguratio return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationTypeArrayOutput) } +func (i ValidatingWebhookConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookConfigurationType] { + return pulumix.Output[[]ValidatingWebhookConfigurationType]{ + OutputState: i.ToValidatingWebhookConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 ValidatingWebhookConfiguration instead. type ValidatingWebhookConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -7161,6 +8014,12 @@ func (o ValidatingWebhookConfigurationTypeOutput) ToValidatingWebhookConfigurati return o } +func (o ValidatingWebhookConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationType] { + return pulumix.Output[ValidatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingWebhookConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7195,6 +8054,12 @@ func (o ValidatingWebhookConfigurationTypeArrayOutput) ToValidatingWebhookConfig return o } +func (o ValidatingWebhookConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookConfigurationType] { + return pulumix.Output[[]ValidatingWebhookConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationTypeArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingWebhookConfigurationType { return vs[0].([]ValidatingWebhookConfigurationType)[vs[1].(int)] @@ -7248,6 +8113,12 @@ func (i ValidatingWebhookConfigurationListTypeArgs) ToValidatingWebhookConfigura return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListTypeOutput) } +func (i ValidatingWebhookConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationListType] { + return pulumix.Output[ValidatingWebhookConfigurationListType]{ + OutputState: i.ToValidatingWebhookConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. type ValidatingWebhookConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -7263,6 +8134,12 @@ func (o ValidatingWebhookConfigurationListTypeOutput) ToValidatingWebhookConfigu return o } +func (o ValidatingWebhookConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationListType] { + return pulumix.Output[ValidatingWebhookConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingWebhookConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7330,6 +8207,12 @@ func (i ValidatingWebhookConfigurationPatchTypeArgs) ToValidatingWebhookConfigur return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchTypeOutput) } +func (i ValidatingWebhookConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationPatchType] { + return pulumix.Output[ValidatingWebhookConfigurationPatchType]{ + OutputState: i.ToValidatingWebhookConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 ValidatingWebhookConfiguration instead. type ValidatingWebhookConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -7345,6 +8228,12 @@ func (o ValidatingWebhookConfigurationPatchTypeOutput) ToValidatingWebhookConfig return o } +func (o ValidatingWebhookConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookConfigurationPatchType] { + return pulumix.Output[ValidatingWebhookConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidatingWebhookConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7508,6 +8397,12 @@ func (i ValidatingWebhookPatchArgs) ToValidatingWebhookPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookPatchOutput) } +func (i ValidatingWebhookPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookPatch] { + return pulumix.Output[ValidatingWebhookPatch]{ + OutputState: i.ToValidatingWebhookPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookPatchArrayInput is an input type that accepts ValidatingWebhookPatchArray and ValidatingWebhookPatchArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookPatchArrayInput` via: // @@ -7533,6 +8428,12 @@ func (i ValidatingWebhookPatchArray) ToValidatingWebhookPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookPatchArrayOutput) } +func (i ValidatingWebhookPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookPatch] { + return pulumix.Output[[]ValidatingWebhookPatch]{ + OutputState: i.ToValidatingWebhookPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhook describes an admission webhook and the resources and operations it applies to. type ValidatingWebhookPatchOutput struct{ *pulumi.OutputState } @@ -7548,6 +8449,12 @@ func (o ValidatingWebhookPatchOutput) ToValidatingWebhookPatchOutputWithContext( return o } +func (o ValidatingWebhookPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidatingWebhookPatch] { + return pulumix.Output[ValidatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. Default to `['v1beta1']`. func (o ValidatingWebhookPatchOutput) AdmissionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v ValidatingWebhookPatch) []string { return v.AdmissionReviewVersions }).(pulumi.StringArrayOutput) @@ -7648,6 +8555,12 @@ func (o ValidatingWebhookPatchArrayOutput) ToValidatingWebhookPatchArrayOutputWi return o } +func (o ValidatingWebhookPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidatingWebhookPatch] { + return pulumix.Output[[]ValidatingWebhookPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookPatchArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidatingWebhookPatch { return vs[0].([]ValidatingWebhookPatch)[vs[1].(int)] @@ -7751,6 +8664,12 @@ func (i ValidationArgs) ToValidationOutputWithContext(ctx context.Context) Valid return pulumi.ToOutputWithContext(ctx, i).(ValidationOutput) } +func (i ValidationArgs) ToOutput(ctx context.Context) pulumix.Output[Validation] { + return pulumix.Output[Validation]{ + OutputState: i.ToValidationOutputWithContext(ctx).OutputState, + } +} + // ValidationArrayInput is an input type that accepts ValidationArray and ValidationArrayOutput values. // You can construct a concrete instance of `ValidationArrayInput` via: // @@ -7776,6 +8695,12 @@ func (i ValidationArray) ToValidationArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ValidationArrayOutput) } +func (i ValidationArray) ToOutput(ctx context.Context) pulumix.Output[[]Validation] { + return pulumix.Output[[]Validation]{ + OutputState: i.ToValidationArrayOutputWithContext(ctx).OutputState, + } +} + // Validation specifies the CEL expression which is used to apply the validation. type ValidationOutput struct{ *pulumi.OutputState } @@ -7791,6 +8716,12 @@ func (o ValidationOutput) ToValidationOutputWithContext(ctx context.Context) Val return o } +func (o ValidationOutput) ToOutput(ctx context.Context) pulumix.Output[Validation] { + return pulumix.Output[Validation]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec CEL expressions have access to the contents of the API request/response, organized into CEL variables as well as some other useful variables: // // - 'object' - The object from the incoming request. The value is null for DELETE requests. - 'oldObject' - The existing object. The value is null for CREATE requests. - 'request' - Attributes of the API request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value. @@ -7852,6 +8783,12 @@ func (o ValidationArrayOutput) ToValidationArrayOutputWithContext(ctx context.Co return o } +func (o ValidationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Validation] { + return pulumix.Output[[]Validation]{ + OutputState: o.OutputState, + } +} + func (o ValidationArrayOutput) Index(i pulumi.IntInput) ValidationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Validation { return vs[0].([]Validation)[vs[1].(int)] @@ -7955,6 +8892,12 @@ func (i ValidationPatchArgs) ToValidationPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ValidationPatchOutput) } +func (i ValidationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidationPatch] { + return pulumix.Output[ValidationPatch]{ + OutputState: i.ToValidationPatchOutputWithContext(ctx).OutputState, + } +} + // ValidationPatchArrayInput is an input type that accepts ValidationPatchArray and ValidationPatchArrayOutput values. // You can construct a concrete instance of `ValidationPatchArrayInput` via: // @@ -7980,6 +8923,12 @@ func (i ValidationPatchArray) ToValidationPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ValidationPatchArrayOutput) } +func (i ValidationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidationPatch] { + return pulumix.Output[[]ValidationPatch]{ + OutputState: i.ToValidationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Validation specifies the CEL expression which is used to apply the validation. type ValidationPatchOutput struct{ *pulumi.OutputState } @@ -7995,6 +8944,12 @@ func (o ValidationPatchOutput) ToValidationPatchOutputWithContext(ctx context.Co return o } +func (o ValidationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidationPatch] { + return pulumix.Output[ValidationPatch]{ + OutputState: o.OutputState, + } +} + // Expression represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec CEL expressions have access to the contents of the API request/response, organized into CEL variables as well as some other useful variables: // // - 'object' - The object from the incoming request. The value is null for DELETE requests. - 'oldObject' - The existing object. The value is null for CREATE requests. - 'request' - Attributes of the API request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value. @@ -8056,6 +9011,12 @@ func (o ValidationPatchArrayOutput) ToValidationPatchArrayOutputWithContext(ctx return o } +func (o ValidationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidationPatch] { + return pulumix.Output[[]ValidationPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidationPatchArrayOutput) Index(i pulumi.IntInput) ValidationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidationPatch { return vs[0].([]ValidationPatch)[vs[1].(int)] @@ -8101,6 +9062,12 @@ func (i VariableArgs) ToVariableOutputWithContext(ctx context.Context) VariableO return pulumi.ToOutputWithContext(ctx, i).(VariableOutput) } +func (i VariableArgs) ToOutput(ctx context.Context) pulumix.Output[Variable] { + return pulumix.Output[Variable]{ + OutputState: i.ToVariableOutputWithContext(ctx).OutputState, + } +} + // VariableArrayInput is an input type that accepts VariableArray and VariableArrayOutput values. // You can construct a concrete instance of `VariableArrayInput` via: // @@ -8126,6 +9093,12 @@ func (i VariableArray) ToVariableArrayOutputWithContext(ctx context.Context) Var return pulumi.ToOutputWithContext(ctx, i).(VariableArrayOutput) } +func (i VariableArray) ToOutput(ctx context.Context) pulumix.Output[[]Variable] { + return pulumix.Output[[]Variable]{ + OutputState: i.ToVariableArrayOutputWithContext(ctx).OutputState, + } +} + // Variable is the definition of a variable that is used for composition. A variable is defined as a named expression. type VariableOutput struct{ *pulumi.OutputState } @@ -8141,6 +9114,12 @@ func (o VariableOutput) ToVariableOutputWithContext(ctx context.Context) Variabl return o } +func (o VariableOutput) ToOutput(ctx context.Context) pulumix.Output[Variable] { + return pulumix.Output[Variable]{ + OutputState: o.OutputState, + } +} + // Expression is the expression that will be evaluated as the value of the variable. The CEL expression has access to the same identifiers as the CEL expressions in Validation. func (o VariableOutput) Expression() pulumi.StringOutput { return o.ApplyT(func(v Variable) string { return v.Expression }).(pulumi.StringOutput) @@ -8165,6 +9144,12 @@ func (o VariableArrayOutput) ToVariableArrayOutputWithContext(ctx context.Contex return o } +func (o VariableArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Variable] { + return pulumix.Output[[]Variable]{ + OutputState: o.OutputState, + } +} + func (o VariableArrayOutput) Index(i pulumi.IntInput) VariableOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Variable { return vs[0].([]Variable)[vs[1].(int)] @@ -8210,6 +9195,12 @@ func (i VariablePatchArgs) ToVariablePatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(VariablePatchOutput) } +func (i VariablePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VariablePatch] { + return pulumix.Output[VariablePatch]{ + OutputState: i.ToVariablePatchOutputWithContext(ctx).OutputState, + } +} + // VariablePatchArrayInput is an input type that accepts VariablePatchArray and VariablePatchArrayOutput values. // You can construct a concrete instance of `VariablePatchArrayInput` via: // @@ -8235,6 +9226,12 @@ func (i VariablePatchArray) ToVariablePatchArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VariablePatchArrayOutput) } +func (i VariablePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]VariablePatch] { + return pulumix.Output[[]VariablePatch]{ + OutputState: i.ToVariablePatchArrayOutputWithContext(ctx).OutputState, + } +} + // Variable is the definition of a variable that is used for composition. A variable is defined as a named expression. type VariablePatchOutput struct{ *pulumi.OutputState } @@ -8250,6 +9247,12 @@ func (o VariablePatchOutput) ToVariablePatchOutputWithContext(ctx context.Contex return o } +func (o VariablePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VariablePatch] { + return pulumix.Output[VariablePatch]{ + OutputState: o.OutputState, + } +} + // Expression is the expression that will be evaluated as the value of the variable. The CEL expression has access to the same identifiers as the CEL expressions in Validation. func (o VariablePatchOutput) Expression() pulumi.StringPtrOutput { return o.ApplyT(func(v VariablePatch) *string { return v.Expression }).(pulumi.StringPtrOutput) @@ -8274,6 +9277,12 @@ func (o VariablePatchArrayOutput) ToVariablePatchArrayOutputWithContext(ctx cont return o } +func (o VariablePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VariablePatch] { + return pulumix.Output[[]VariablePatch]{ + OutputState: o.OutputState, + } +} + func (o VariablePatchArrayOutput) Index(i pulumi.IntInput) VariablePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VariablePatch { return vs[0].([]VariablePatch)[vs[1].(int)] @@ -8347,6 +9356,12 @@ func (i WebhookClientConfigArgs) ToWebhookClientConfigOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigOutput) } +func (i WebhookClientConfigArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook type WebhookClientConfigOutput struct{ *pulumi.OutputState } @@ -8362,6 +9377,12 @@ func (o WebhookClientConfigOutput) ToWebhookClientConfigOutputWithContext(ctx co return o } +func (o WebhookClientConfigOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + // `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfig) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -8456,6 +9477,12 @@ func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchOutput) } +func (i WebhookClientConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchPtrOutput() WebhookClientConfigPatchPtrOutput { return i.ToWebhookClientConfigPatchPtrOutputWithContext(context.Background()) } @@ -8497,6 +9524,12 @@ func (i *webhookClientConfigPatchPtrType) ToWebhookClientConfigPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchPtrOutput) } +func (i *webhookClientConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook type WebhookClientConfigPatchOutput struct{ *pulumi.OutputState } @@ -8522,6 +9555,12 @@ func (o WebhookClientConfigPatchOutput) ToWebhookClientConfigPatchPtrOutputWithC }).(WebhookClientConfigPatchPtrOutput) } +func (o WebhookClientConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + // `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfigPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -8563,6 +9602,12 @@ func (o WebhookClientConfigPatchPtrOutput) ToWebhookClientConfigPatchPtrOutputWi return o } +func (o WebhookClientConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPatchPtrOutput) Elem() WebhookClientConfigPatchOutput { return o.ApplyT(func(v *WebhookClientConfigPatch) WebhookClientConfigPatch { if v != nil { diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicy.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicy.go index 2000494eea..0d1af50aa5 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicy.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicy.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicy describes the definition of an admission validation policy that accepts or rejects an object without changing it. @@ -121,6 +122,12 @@ func (i *ValidatingAdmissionPolicy) ToValidatingAdmissionPolicyOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyOutput) } +func (i *ValidatingAdmissionPolicy) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicy] { + return pulumix.Output[*ValidatingAdmissionPolicy]{ + OutputState: i.ToValidatingAdmissionPolicyOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyArrayInput is an input type that accepts ValidatingAdmissionPolicyArray and ValidatingAdmissionPolicyArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyArrayInput` via: // @@ -146,6 +153,12 @@ func (i ValidatingAdmissionPolicyArray) ToValidatingAdmissionPolicyArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyArrayOutput) } +func (i ValidatingAdmissionPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicy] { + return pulumix.Output[[]*ValidatingAdmissionPolicy]{ + OutputState: i.ToValidatingAdmissionPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyMapInput is an input type that accepts ValidatingAdmissionPolicyMap and ValidatingAdmissionPolicyMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyMapInput` via: // @@ -171,6 +184,12 @@ func (i ValidatingAdmissionPolicyMap) ToValidatingAdmissionPolicyMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyMapOutput) } +func (i ValidatingAdmissionPolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicy] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicy]{ + OutputState: i.ToValidatingAdmissionPolicyMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o ValidatingAdmissionPolicyOutput) ToValidatingAdmissionPolicyOutputWithCo return o } +func (o ValidatingAdmissionPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicy] { + return pulumix.Output[*ValidatingAdmissionPolicy]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicy) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o ValidatingAdmissionPolicyArrayOutput) ToValidatingAdmissionPolicyArrayOu return o } +func (o ValidatingAdmissionPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicy] { + return pulumix.Output[[]*ValidatingAdmissionPolicy]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicy { return vs[0].([]*ValidatingAdmissionPolicy)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o ValidatingAdmissionPolicyMapOutput) ToValidatingAdmissionPolicyMapOutput return o } +func (o ValidatingAdmissionPolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicy] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicy]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicy { return vs[0].(map[string]*ValidatingAdmissionPolicy)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBinding.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBinding.go index cb686ed2d2..f48e1d41d1 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBinding.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBinding.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicyBinding binds the ValidatingAdmissionPolicy with paramerized resources. ValidatingAdmissionPolicyBinding and parameter CRDs together define how cluster administrators configure policies for clusters. @@ -123,6 +124,12 @@ func (i *ValidatingAdmissionPolicyBinding) ToValidatingAdmissionPolicyBindingOut return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingOutput) } +func (i *ValidatingAdmissionPolicyBinding) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[*ValidatingAdmissionPolicyBinding]{ + OutputState: i.ToValidatingAdmissionPolicyBindingOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingArray and ValidatingAdmissionPolicyBindingArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingArrayInput` via: // @@ -148,6 +155,12 @@ func (i ValidatingAdmissionPolicyBindingArray) ToValidatingAdmissionPolicyBindin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingArrayOutput) } +func (i ValidatingAdmissionPolicyBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBinding]{ + OutputState: i.ToValidatingAdmissionPolicyBindingArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingMapInput is an input type that accepts ValidatingAdmissionPolicyBindingMap and ValidatingAdmissionPolicyBindingMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingMapInput` via: // @@ -173,6 +186,12 @@ func (i ValidatingAdmissionPolicyBindingMap) ToValidatingAdmissionPolicyBindingM return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingMapOutput) } +func (i ValidatingAdmissionPolicyBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding]{ + OutputState: i.ToValidatingAdmissionPolicyBindingMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyBindingOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyBindingOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o ValidatingAdmissionPolicyBindingOutput) ToValidatingAdmissionPolicyBindi return o } +func (o ValidatingAdmissionPolicyBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[*ValidatingAdmissionPolicyBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -221,6 +246,12 @@ func (o ValidatingAdmissionPolicyBindingArrayOutput) ToValidatingAdmissionPolicy return o } +func (o ValidatingAdmissionPolicyBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBinding]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBinding { return vs[0].([]*ValidatingAdmissionPolicyBinding)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o ValidatingAdmissionPolicyBindingMapOutput) ToValidatingAdmissionPolicyBi return o } +func (o ValidatingAdmissionPolicyBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBinding]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBinding { return vs[0].(map[string]*ValidatingAdmissionPolicyBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingList.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingList.go index 82be33c94d..be14eadda0 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingList.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingList.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicyBindingList is a list of ValidatingAdmissionPolicyBinding. @@ -113,6 +114,12 @@ func (i *ValidatingAdmissionPolicyBindingList) ToValidatingAdmissionPolicyBindin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListOutput) } +func (i *ValidatingAdmissionPolicyBindingList) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingList]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingListArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingListArray and ValidatingAdmissionPolicyBindingListArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingListArrayInput` via: // @@ -138,6 +145,12 @@ func (i ValidatingAdmissionPolicyBindingListArray) ToValidatingAdmissionPolicyBi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListArrayOutput) } +func (i ValidatingAdmissionPolicyBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingList]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingListMapInput is an input type that accepts ValidatingAdmissionPolicyBindingListMap and ValidatingAdmissionPolicyBindingListMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingListMapInput` via: // @@ -163,6 +176,12 @@ func (i ValidatingAdmissionPolicyBindingListMap) ToValidatingAdmissionPolicyBind return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingListMapOutput) } +func (i ValidatingAdmissionPolicyBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList]{ + OutputState: i.ToValidatingAdmissionPolicyBindingListMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyBindingListOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyBindingListOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o ValidatingAdmissionPolicyBindingListOutput) ToValidatingAdmissionPolicyB return o } +func (o ValidatingAdmissionPolicyBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -213,6 +238,12 @@ func (o ValidatingAdmissionPolicyBindingListArrayOutput) ToValidatingAdmissionPo return o } +func (o ValidatingAdmissionPolicyBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingListArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingList { return vs[0].([]*ValidatingAdmissionPolicyBindingList)[vs[1].(int)] @@ -233,6 +264,12 @@ func (o ValidatingAdmissionPolicyBindingListMapOutput) ToValidatingAdmissionPoli return o } +func (o ValidatingAdmissionPolicyBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingListMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingList { return vs[0].(map[string]*ValidatingAdmissionPolicyBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingPatch.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingPatch.go index ed40322791..99a01f0a36 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -129,6 +130,12 @@ func (i *ValidatingAdmissionPolicyBindingPatch) ToValidatingAdmissionPolicyBindi return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchOutput) } +func (i *ValidatingAdmissionPolicyBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingPatchArrayInput is an input type that accepts ValidatingAdmissionPolicyBindingPatchArray and ValidatingAdmissionPolicyBindingPatchArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingPatchArrayInput` via: // @@ -154,6 +161,12 @@ func (i ValidatingAdmissionPolicyBindingPatchArray) ToValidatingAdmissionPolicyB return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchArrayOutput) } +func (i ValidatingAdmissionPolicyBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyBindingPatchMapInput is an input type that accepts ValidatingAdmissionPolicyBindingPatchMap and ValidatingAdmissionPolicyBindingPatchMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyBindingPatchMapInput` via: // @@ -179,6 +192,12 @@ func (i ValidatingAdmissionPolicyBindingPatchMap) ToValidatingAdmissionPolicyBin return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyBindingPatchMapOutput) } +func (i ValidatingAdmissionPolicyBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: i.ToValidatingAdmissionPolicyBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyBindingPatchOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyBindingPatchOutput) ElementType() reflect.Type { @@ -193,6 +212,12 @@ func (o ValidatingAdmissionPolicyBindingPatchOutput) ToValidatingAdmissionPolicy return o } +func (o ValidatingAdmissionPolicyBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -229,6 +254,12 @@ func (o ValidatingAdmissionPolicyBindingPatchArrayOutput) ToValidatingAdmissionP return o } +func (o ValidatingAdmissionPolicyBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingPatchArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingPatch { return vs[0].([]*ValidatingAdmissionPolicyBindingPatch)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o ValidatingAdmissionPolicyBindingPatchMapOutput) ToValidatingAdmissionPol return o } +func (o ValidatingAdmissionPolicyBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyBindingPatchMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyBindingPatch { return vs[0].(map[string]*ValidatingAdmissionPolicyBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyList.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyList.go index 2af032103b..fcd8ac1003 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyList.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyList.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingAdmissionPolicyList is a list of ValidatingAdmissionPolicy. @@ -113,6 +114,12 @@ func (i *ValidatingAdmissionPolicyList) ToValidatingAdmissionPolicyListOutputWit return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListOutput) } +func (i *ValidatingAdmissionPolicyList) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyList] { + return pulumix.Output[*ValidatingAdmissionPolicyList]{ + OutputState: i.ToValidatingAdmissionPolicyListOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyListArrayInput is an input type that accepts ValidatingAdmissionPolicyListArray and ValidatingAdmissionPolicyListArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyListArrayInput` via: // @@ -138,6 +145,12 @@ func (i ValidatingAdmissionPolicyListArray) ToValidatingAdmissionPolicyListArray return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListArrayOutput) } +func (i ValidatingAdmissionPolicyListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyList]{ + OutputState: i.ToValidatingAdmissionPolicyListArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyListMapInput is an input type that accepts ValidatingAdmissionPolicyListMap and ValidatingAdmissionPolicyListMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyListMapInput` via: // @@ -163,6 +176,12 @@ func (i ValidatingAdmissionPolicyListMap) ToValidatingAdmissionPolicyListMapOutp return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyListMapOutput) } +func (i ValidatingAdmissionPolicyListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyList]{ + OutputState: i.ToValidatingAdmissionPolicyListMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyListOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyListOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o ValidatingAdmissionPolicyListOutput) ToValidatingAdmissionPolicyListOutp return o } +func (o ValidatingAdmissionPolicyListOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyList] { + return pulumix.Output[*ValidatingAdmissionPolicyList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o ValidatingAdmissionPolicyListArrayOutput) ToValidatingAdmissionPolicyLis return o } +func (o ValidatingAdmissionPolicyListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyList] { + return pulumix.Output[[]*ValidatingAdmissionPolicyList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyListArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyList { return vs[0].([]*ValidatingAdmissionPolicyList)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o ValidatingAdmissionPolicyListMapOutput) ToValidatingAdmissionPolicyListM return o } +func (o ValidatingAdmissionPolicyListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyList] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyListMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyList { return vs[0].(map[string]*ValidatingAdmissionPolicyList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyPatch.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyPatch.go index 94c993a2fe..c6522b54da 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingAdmissionPolicyPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -127,6 +128,12 @@ func (i *ValidatingAdmissionPolicyPatch) ToValidatingAdmissionPolicyPatchOutputW return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchOutput) } +func (i *ValidatingAdmissionPolicyPatch) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyPatch]{ + OutputState: i.ToValidatingAdmissionPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyPatchArrayInput is an input type that accepts ValidatingAdmissionPolicyPatchArray and ValidatingAdmissionPolicyPatchArrayOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyPatchArrayInput` via: // @@ -152,6 +159,12 @@ func (i ValidatingAdmissionPolicyPatchArray) ToValidatingAdmissionPolicyPatchArr return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchArrayOutput) } +func (i ValidatingAdmissionPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyPatch]{ + OutputState: i.ToValidatingAdmissionPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingAdmissionPolicyPatchMapInput is an input type that accepts ValidatingAdmissionPolicyPatchMap and ValidatingAdmissionPolicyPatchMapOutput values. // You can construct a concrete instance of `ValidatingAdmissionPolicyPatchMapInput` via: // @@ -177,6 +190,12 @@ func (i ValidatingAdmissionPolicyPatchMap) ToValidatingAdmissionPolicyPatchMapOu return pulumi.ToOutputWithContext(ctx, i).(ValidatingAdmissionPolicyPatchMapOutput) } +func (i ValidatingAdmissionPolicyPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch]{ + OutputState: i.ToValidatingAdmissionPolicyPatchMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingAdmissionPolicyPatchOutput struct{ *pulumi.OutputState } func (ValidatingAdmissionPolicyPatchOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o ValidatingAdmissionPolicyPatchOutput) ToValidatingAdmissionPolicyPatchOu return o } +func (o ValidatingAdmissionPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[*ValidatingAdmissionPolicyPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingAdmissionPolicyPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ValidatingAdmissionPolicyPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -230,6 +255,12 @@ func (o ValidatingAdmissionPolicyPatchArrayOutput) ToValidatingAdmissionPolicyPa return o } +func (o ValidatingAdmissionPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[[]*ValidatingAdmissionPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyPatchArrayOutput) Index(i pulumi.IntInput) ValidatingAdmissionPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyPatch { return vs[0].([]*ValidatingAdmissionPolicyPatch)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o ValidatingAdmissionPolicyPatchMapOutput) ToValidatingAdmissionPolicyPatc return o } +func (o ValidatingAdmissionPolicyPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch] { + return pulumix.Output[map[string]*ValidatingAdmissionPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingAdmissionPolicyPatchMapOutput) MapIndex(k pulumi.StringInput) ValidatingAdmissionPolicyPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingAdmissionPolicyPatch { return vs[0].(map[string]*ValidatingAdmissionPolicyPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfiguration.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfiguration.go index 691686c65e..b242d29eff 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfiguration.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 ValidatingWebhookConfiguration instead. @@ -119,6 +120,12 @@ func (i *ValidatingWebhookConfiguration) ToValidatingWebhookConfigurationOutputW return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationOutput) } +func (i *ValidatingWebhookConfiguration) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfiguration] { + return pulumix.Output[*ValidatingWebhookConfiguration]{ + OutputState: i.ToValidatingWebhookConfigurationOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationArrayInput is an input type that accepts ValidatingWebhookConfigurationArray and ValidatingWebhookConfigurationArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationArrayInput` via: // @@ -144,6 +151,12 @@ func (i ValidatingWebhookConfigurationArray) ToValidatingWebhookConfigurationArr return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationArrayOutput) } +func (i ValidatingWebhookConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfiguration] { + return pulumix.Output[[]*ValidatingWebhookConfiguration]{ + OutputState: i.ToValidatingWebhookConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationMapInput is an input type that accepts ValidatingWebhookConfigurationMap and ValidatingWebhookConfigurationMapOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationMapInput` via: // @@ -169,6 +182,12 @@ func (i ValidatingWebhookConfigurationMap) ToValidatingWebhookConfigurationMapOu return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationMapOutput) } +func (i ValidatingWebhookConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfiguration] { + return pulumix.Output[map[string]*ValidatingWebhookConfiguration]{ + OutputState: i.ToValidatingWebhookConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingWebhookConfigurationOutput struct{ *pulumi.OutputState } func (ValidatingWebhookConfigurationOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o ValidatingWebhookConfigurationOutput) ToValidatingWebhookConfigurationOu return o } +func (o ValidatingWebhookConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfiguration] { + return pulumix.Output[*ValidatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingWebhookConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o ValidatingWebhookConfigurationArrayOutput) ToValidatingWebhookConfigurat return o } +func (o ValidatingWebhookConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfiguration] { + return pulumix.Output[[]*ValidatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingWebhookConfiguration { return vs[0].([]*ValidatingWebhookConfiguration)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o ValidatingWebhookConfigurationMapOutput) ToValidatingWebhookConfiguratio return o } +func (o ValidatingWebhookConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfiguration] { + return pulumix.Output[map[string]*ValidatingWebhookConfiguration]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationMapOutput) MapIndex(k pulumi.StringInput) ValidatingWebhookConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingWebhookConfiguration { return vs[0].(map[string]*ValidatingWebhookConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationList.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationList.go index d599b30bd5..d174dc6fc2 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationList.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. @@ -117,6 +118,12 @@ func (i *ValidatingWebhookConfigurationList) ToValidatingWebhookConfigurationLis return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListOutput) } +func (i *ValidatingWebhookConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationList] { + return pulumix.Output[*ValidatingWebhookConfigurationList]{ + OutputState: i.ToValidatingWebhookConfigurationListOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationListArrayInput is an input type that accepts ValidatingWebhookConfigurationListArray and ValidatingWebhookConfigurationListArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ValidatingWebhookConfigurationListArray) ToValidatingWebhookConfiguratio return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListArrayOutput) } +func (i ValidatingWebhookConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationList] { + return pulumix.Output[[]*ValidatingWebhookConfigurationList]{ + OutputState: i.ToValidatingWebhookConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationListMapInput is an input type that accepts ValidatingWebhookConfigurationListMap and ValidatingWebhookConfigurationListMapOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i ValidatingWebhookConfigurationListMap) ToValidatingWebhookConfigurationL return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationListMapOutput) } +func (i ValidatingWebhookConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationList] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationList]{ + OutputState: i.ToValidatingWebhookConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingWebhookConfigurationListOutput struct{ *pulumi.OutputState } func (ValidatingWebhookConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ValidatingWebhookConfigurationListOutput) ToValidatingWebhookConfigurati return o } +func (o ValidatingWebhookConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationList] { + return pulumix.Output[*ValidatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ValidatingWebhookConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o ValidatingWebhookConfigurationListArrayOutput) ToValidatingWebhookConfig return o } +func (o ValidatingWebhookConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationList] { + return pulumix.Output[[]*ValidatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationListArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationList { return vs[0].([]*ValidatingWebhookConfigurationList)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o ValidatingWebhookConfigurationListMapOutput) ToValidatingWebhookConfigur return o } +func (o ValidatingWebhookConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationList] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationListMapOutput) MapIndex(k pulumi.StringInput) ValidatingWebhookConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationList { return vs[0].(map[string]*ValidatingWebhookConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationPatch.go b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationPatch.go index 85b50274cd..6b91015ebe 100644 --- a/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationPatch.go +++ b/sdk/go/kubernetes/admissionregistration/v1beta1/validatingWebhookConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *ValidatingWebhookConfigurationPatch) ToValidatingWebhookConfigurationPa return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchOutput) } +func (i *ValidatingWebhookConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[*ValidatingWebhookConfigurationPatch]{ + OutputState: i.ToValidatingWebhookConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationPatchArrayInput is an input type that accepts ValidatingWebhookConfigurationPatchArray and ValidatingWebhookConfigurationPatchArrayOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i ValidatingWebhookConfigurationPatchArray) ToValidatingWebhookConfigurati return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchArrayOutput) } +func (i ValidatingWebhookConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[[]*ValidatingWebhookConfigurationPatch]{ + OutputState: i.ToValidatingWebhookConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidatingWebhookConfigurationPatchMapInput is an input type that accepts ValidatingWebhookConfigurationPatchMap and ValidatingWebhookConfigurationPatchMapOutput values. // You can construct a concrete instance of `ValidatingWebhookConfigurationPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i ValidatingWebhookConfigurationPatchMap) ToValidatingWebhookConfiguration return pulumi.ToOutputWithContext(ctx, i).(ValidatingWebhookConfigurationPatchMapOutput) } +func (i ValidatingWebhookConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch]{ + OutputState: i.ToValidatingWebhookConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type ValidatingWebhookConfigurationPatchOutput struct{ *pulumi.OutputState } func (ValidatingWebhookConfigurationPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o ValidatingWebhookConfigurationPatchOutput) ToValidatingWebhookConfigurat return o } +func (o ValidatingWebhookConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[*ValidatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ValidatingWebhookConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ValidatingWebhookConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o ValidatingWebhookConfigurationPatchArrayOutput) ToValidatingWebhookConfi return o } +func (o ValidatingWebhookConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[[]*ValidatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationPatchArrayOutput) Index(i pulumi.IntInput) ValidatingWebhookConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationPatch { return vs[0].([]*ValidatingWebhookConfigurationPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o ValidatingWebhookConfigurationPatchMapOutput) ToValidatingWebhookConfigu return o } +func (o ValidatingWebhookConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch] { + return pulumix.Output[map[string]*ValidatingWebhookConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o ValidatingWebhookConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) ValidatingWebhookConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ValidatingWebhookConfigurationPatch { return vs[0].(map[string]*ValidatingWebhookConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1/customResourceDefinition.go b/sdk/go/kubernetes/apiextensions/v1/customResourceDefinition.go index 0d538fd84a..6f03b0d6bf 100644 --- a/sdk/go/kubernetes/apiextensions/v1/customResourceDefinition.go +++ b/sdk/go/kubernetes/apiextensions/v1/customResourceDefinition.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. @@ -125,6 +126,12 @@ func (i *CustomResourceDefinition) ToCustomResourceDefinitionOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionOutput) } +func (i *CustomResourceDefinition) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinition] { + return pulumix.Output[*CustomResourceDefinition]{ + OutputState: i.ToCustomResourceDefinitionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionArrayInput is an input type that accepts CustomResourceDefinitionArray and CustomResourceDefinitionArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionArrayInput` via: // @@ -150,6 +157,12 @@ func (i CustomResourceDefinitionArray) ToCustomResourceDefinitionArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionArrayOutput) } +func (i CustomResourceDefinitionArray) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinition] { + return pulumix.Output[[]*CustomResourceDefinition]{ + OutputState: i.ToCustomResourceDefinitionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionMapInput is an input type that accepts CustomResourceDefinitionMap and CustomResourceDefinitionMapOutput values. // You can construct a concrete instance of `CustomResourceDefinitionMapInput` via: // @@ -175,6 +188,12 @@ func (i CustomResourceDefinitionMap) ToCustomResourceDefinitionMapOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionMapOutput) } +func (i CustomResourceDefinitionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinition] { + return pulumix.Output[map[string]*CustomResourceDefinition]{ + OutputState: i.ToCustomResourceDefinitionMapOutputWithContext(ctx).OutputState, + } +} + type CustomResourceDefinitionOutput struct{ *pulumi.OutputState } func (CustomResourceDefinitionOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o CustomResourceDefinitionOutput) ToCustomResourceDefinitionOutputWithCont return o } +func (o CustomResourceDefinitionOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinition] { + return pulumix.Output[*CustomResourceDefinition]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CustomResourceDefinition) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -228,6 +253,12 @@ func (o CustomResourceDefinitionArrayOutput) ToCustomResourceDefinitionArrayOutp return o } +func (o CustomResourceDefinitionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinition] { + return pulumix.Output[[]*CustomResourceDefinition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CustomResourceDefinition { return vs[0].([]*CustomResourceDefinition)[vs[1].(int)] @@ -248,6 +279,12 @@ func (o CustomResourceDefinitionMapOutput) ToCustomResourceDefinitionMapOutputWi return o } +func (o CustomResourceDefinitionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinition] { + return pulumix.Output[map[string]*CustomResourceDefinition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionMapOutput) MapIndex(k pulumi.StringInput) CustomResourceDefinitionOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CustomResourceDefinition { return vs[0].(map[string]*CustomResourceDefinition)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionList.go b/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionList.go index de5775a01c..29641520da 100644 --- a/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionList.go +++ b/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CustomResourceDefinitionList is a list of CustomResourceDefinition objects. @@ -117,6 +118,12 @@ func (i *CustomResourceDefinitionList) ToCustomResourceDefinitionListOutputWithC return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListOutput) } +func (i *CustomResourceDefinitionList) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionList] { + return pulumix.Output[*CustomResourceDefinitionList]{ + OutputState: i.ToCustomResourceDefinitionListOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionListArrayInput is an input type that accepts CustomResourceDefinitionListArray and CustomResourceDefinitionListArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CustomResourceDefinitionListArray) ToCustomResourceDefinitionListArrayOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListArrayOutput) } +func (i CustomResourceDefinitionListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionList] { + return pulumix.Output[[]*CustomResourceDefinitionList]{ + OutputState: i.ToCustomResourceDefinitionListArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionListMapInput is an input type that accepts CustomResourceDefinitionListMap and CustomResourceDefinitionListMapOutput values. // You can construct a concrete instance of `CustomResourceDefinitionListMapInput` via: // @@ -167,6 +180,12 @@ func (i CustomResourceDefinitionListMap) ToCustomResourceDefinitionListMapOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListMapOutput) } +func (i CustomResourceDefinitionListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionList] { + return pulumix.Output[map[string]*CustomResourceDefinitionList]{ + OutputState: i.ToCustomResourceDefinitionListMapOutputWithContext(ctx).OutputState, + } +} + type CustomResourceDefinitionListOutput struct{ *pulumi.OutputState } func (CustomResourceDefinitionListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CustomResourceDefinitionListOutput) ToCustomResourceDefinitionListOutput return o } +func (o CustomResourceDefinitionListOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionList] { + return pulumix.Output[*CustomResourceDefinitionList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CustomResourceDefinitionList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CustomResourceDefinitionListArrayOutput) ToCustomResourceDefinitionListA return o } +func (o CustomResourceDefinitionListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionList] { + return pulumix.Output[[]*CustomResourceDefinitionList]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionListArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CustomResourceDefinitionList { return vs[0].([]*CustomResourceDefinitionList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CustomResourceDefinitionListMapOutput) ToCustomResourceDefinitionListMap return o } +func (o CustomResourceDefinitionListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionList] { + return pulumix.Output[map[string]*CustomResourceDefinitionList]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionListMapOutput) MapIndex(k pulumi.StringInput) CustomResourceDefinitionListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CustomResourceDefinitionList { return vs[0].(map[string]*CustomResourceDefinitionList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionPatch.go b/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionPatch.go index a5da559581..83acc55127 100644 --- a/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionPatch.go +++ b/sdk/go/kubernetes/apiextensions/v1/customResourceDefinitionPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -127,6 +128,12 @@ func (i *CustomResourceDefinitionPatch) ToCustomResourceDefinitionPatchOutputWit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchOutput) } +func (i *CustomResourceDefinitionPatch) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionPatch] { + return pulumix.Output[*CustomResourceDefinitionPatch]{ + OutputState: i.ToCustomResourceDefinitionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionPatchArrayInput is an input type that accepts CustomResourceDefinitionPatchArray and CustomResourceDefinitionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionPatchArrayInput` via: // @@ -152,6 +159,12 @@ func (i CustomResourceDefinitionPatchArray) ToCustomResourceDefinitionPatchArray return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchArrayOutput) } +func (i CustomResourceDefinitionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionPatch] { + return pulumix.Output[[]*CustomResourceDefinitionPatch]{ + OutputState: i.ToCustomResourceDefinitionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionPatchMapInput is an input type that accepts CustomResourceDefinitionPatchMap and CustomResourceDefinitionPatchMapOutput values. // You can construct a concrete instance of `CustomResourceDefinitionPatchMapInput` via: // @@ -177,6 +190,12 @@ func (i CustomResourceDefinitionPatchMap) ToCustomResourceDefinitionPatchMapOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchMapOutput) } +func (i CustomResourceDefinitionPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionPatch] { + return pulumix.Output[map[string]*CustomResourceDefinitionPatch]{ + OutputState: i.ToCustomResourceDefinitionPatchMapOutputWithContext(ctx).OutputState, + } +} + type CustomResourceDefinitionPatchOutput struct{ *pulumi.OutputState } func (CustomResourceDefinitionPatchOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o CustomResourceDefinitionPatchOutput) ToCustomResourceDefinitionPatchOutp return o } +func (o CustomResourceDefinitionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionPatch] { + return pulumix.Output[*CustomResourceDefinitionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CustomResourceDefinitionPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -230,6 +255,12 @@ func (o CustomResourceDefinitionPatchArrayOutput) ToCustomResourceDefinitionPatc return o } +func (o CustomResourceDefinitionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionPatch] { + return pulumix.Output[[]*CustomResourceDefinitionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CustomResourceDefinitionPatch { return vs[0].([]*CustomResourceDefinitionPatch)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o CustomResourceDefinitionPatchMapOutput) ToCustomResourceDefinitionPatchM return o } +func (o CustomResourceDefinitionPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionPatch] { + return pulumix.Output[map[string]*CustomResourceDefinitionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionPatchMapOutput) MapIndex(k pulumi.StringInput) CustomResourceDefinitionPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CustomResourceDefinitionPatch { return vs[0].(map[string]*CustomResourceDefinitionPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1/pulumiTypes.go b/sdk/go/kubernetes/apiextensions/v1/pulumiTypes.go index bba2a161ab..000c5c4a1f 100644 --- a/sdk/go/kubernetes/apiextensions/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/apiextensions/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -69,6 +70,12 @@ func (i CustomResourceColumnDefinitionArgs) ToCustomResourceColumnDefinitionOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionOutput) } +func (i CustomResourceColumnDefinitionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinition] { + return pulumix.Output[CustomResourceColumnDefinition]{ + OutputState: i.ToCustomResourceColumnDefinitionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinitionArrayInput is an input type that accepts CustomResourceColumnDefinitionArray and CustomResourceColumnDefinitionArrayOutput values. // You can construct a concrete instance of `CustomResourceColumnDefinitionArrayInput` via: // @@ -94,6 +101,12 @@ func (i CustomResourceColumnDefinitionArray) ToCustomResourceColumnDefinitionArr return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionArrayOutput) } +func (i CustomResourceColumnDefinitionArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinition] { + return pulumix.Output[[]CustomResourceColumnDefinition]{ + OutputState: i.ToCustomResourceColumnDefinitionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinition specifies a column for server side printing. type CustomResourceColumnDefinitionOutput struct{ *pulumi.OutputState } @@ -109,6 +122,12 @@ func (o CustomResourceColumnDefinitionOutput) ToCustomResourceColumnDefinitionOu return o } +func (o CustomResourceColumnDefinitionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinition] { + return pulumix.Output[CustomResourceColumnDefinition]{ + OutputState: o.OutputState, + } +} + // description is a human readable description of this column. func (o CustomResourceColumnDefinitionOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceColumnDefinition) *string { return v.Description }).(pulumi.StringPtrOutput) @@ -153,6 +172,12 @@ func (o CustomResourceColumnDefinitionArrayOutput) ToCustomResourceColumnDefinit return o } +func (o CustomResourceColumnDefinitionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinition] { + return pulumix.Output[[]CustomResourceColumnDefinition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceColumnDefinitionArrayOutput) Index(i pulumi.IntInput) CustomResourceColumnDefinitionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceColumnDefinition { return vs[0].([]CustomResourceColumnDefinition)[vs[1].(int)] @@ -214,6 +239,12 @@ func (i CustomResourceColumnDefinitionPatchArgs) ToCustomResourceColumnDefinitio return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionPatchOutput) } +func (i CustomResourceColumnDefinitionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinitionPatch] { + return pulumix.Output[CustomResourceColumnDefinitionPatch]{ + OutputState: i.ToCustomResourceColumnDefinitionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinitionPatchArrayInput is an input type that accepts CustomResourceColumnDefinitionPatchArray and CustomResourceColumnDefinitionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceColumnDefinitionPatchArrayInput` via: // @@ -239,6 +270,12 @@ func (i CustomResourceColumnDefinitionPatchArray) ToCustomResourceColumnDefiniti return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionPatchArrayOutput) } +func (i CustomResourceColumnDefinitionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinitionPatch] { + return pulumix.Output[[]CustomResourceColumnDefinitionPatch]{ + OutputState: i.ToCustomResourceColumnDefinitionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinition specifies a column for server side printing. type CustomResourceColumnDefinitionPatchOutput struct{ *pulumi.OutputState } @@ -254,6 +291,12 @@ func (o CustomResourceColumnDefinitionPatchOutput) ToCustomResourceColumnDefinit return o } +func (o CustomResourceColumnDefinitionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinitionPatch] { + return pulumix.Output[CustomResourceColumnDefinitionPatch]{ + OutputState: o.OutputState, + } +} + // description is a human readable description of this column. func (o CustomResourceColumnDefinitionPatchOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceColumnDefinitionPatch) *string { return v.Description }).(pulumi.StringPtrOutput) @@ -298,6 +341,12 @@ func (o CustomResourceColumnDefinitionPatchArrayOutput) ToCustomResourceColumnDe return o } +func (o CustomResourceColumnDefinitionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinitionPatch] { + return pulumix.Output[[]CustomResourceColumnDefinitionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceColumnDefinitionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceColumnDefinitionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceColumnDefinitionPatch { return vs[0].([]CustomResourceColumnDefinitionPatch)[vs[1].(int)] @@ -345,6 +394,12 @@ func (i CustomResourceConversionArgs) ToCustomResourceConversionOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionOutput) } +func (i CustomResourceConversionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversion] { + return pulumix.Output[CustomResourceConversion]{ + OutputState: i.ToCustomResourceConversionOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceConversionArgs) ToCustomResourceConversionPtrOutput() CustomResourceConversionPtrOutput { return i.ToCustomResourceConversionPtrOutputWithContext(context.Background()) } @@ -386,6 +441,12 @@ func (i *customResourceConversionPtrType) ToCustomResourceConversionPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionPtrOutput) } +func (i *customResourceConversionPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversion] { + return pulumix.Output[*CustomResourceConversion]{ + OutputState: i.ToCustomResourceConversionPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceConversion describes how to convert different versions of a CR. type CustomResourceConversionOutput struct{ *pulumi.OutputState } @@ -411,6 +472,12 @@ func (o CustomResourceConversionOutput) ToCustomResourceConversionPtrOutputWithC }).(CustomResourceConversionPtrOutput) } +func (o CustomResourceConversionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversion] { + return pulumix.Output[CustomResourceConversion]{ + OutputState: o.OutputState, + } +} + // strategy specifies how custom resources are converted between versions. Allowed values are: - `"None"`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `"Webhook"`: API Server will call to an external webhook to do the conversion. Additional information // // is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set. @@ -437,6 +504,12 @@ func (o CustomResourceConversionPtrOutput) ToCustomResourceConversionPtrOutputWi return o } +func (o CustomResourceConversionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversion] { + return pulumix.Output[*CustomResourceConversion]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceConversionPtrOutput) Elem() CustomResourceConversionOutput { return o.ApplyT(func(v *CustomResourceConversion) CustomResourceConversion { if v != nil { @@ -510,6 +583,12 @@ func (i CustomResourceConversionPatchArgs) ToCustomResourceConversionPatchOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionPatchOutput) } +func (i CustomResourceConversionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversionPatch] { + return pulumix.Output[CustomResourceConversionPatch]{ + OutputState: i.ToCustomResourceConversionPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceConversionPatchArgs) ToCustomResourceConversionPatchPtrOutput() CustomResourceConversionPatchPtrOutput { return i.ToCustomResourceConversionPatchPtrOutputWithContext(context.Background()) } @@ -551,6 +630,12 @@ func (i *customResourceConversionPatchPtrType) ToCustomResourceConversionPatchPt return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionPatchPtrOutput) } +func (i *customResourceConversionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversionPatch] { + return pulumix.Output[*CustomResourceConversionPatch]{ + OutputState: i.ToCustomResourceConversionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceConversion describes how to convert different versions of a CR. type CustomResourceConversionPatchOutput struct{ *pulumi.OutputState } @@ -576,6 +661,12 @@ func (o CustomResourceConversionPatchOutput) ToCustomResourceConversionPatchPtrO }).(CustomResourceConversionPatchPtrOutput) } +func (o CustomResourceConversionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversionPatch] { + return pulumix.Output[CustomResourceConversionPatch]{ + OutputState: o.OutputState, + } +} + // strategy specifies how custom resources are converted between versions. Allowed values are: - `"None"`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `"Webhook"`: API Server will call to an external webhook to do the conversion. Additional information // // is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set. @@ -602,6 +693,12 @@ func (o CustomResourceConversionPatchPtrOutput) ToCustomResourceConversionPatchP return o } +func (o CustomResourceConversionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversionPatch] { + return pulumix.Output[*CustomResourceConversionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceConversionPatchPtrOutput) Elem() CustomResourceConversionPatchOutput { return o.ApplyT(func(v *CustomResourceConversionPatch) CustomResourceConversionPatch { if v != nil { @@ -685,6 +782,12 @@ func (i CustomResourceDefinitionTypeArgs) ToCustomResourceDefinitionTypeOutputWi return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionTypeOutput) } +func (i CustomResourceDefinitionTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionType] { + return pulumix.Output[CustomResourceDefinitionType]{ + OutputState: i.ToCustomResourceDefinitionTypeOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionTypeArrayInput is an input type that accepts CustomResourceDefinitionTypeArray and CustomResourceDefinitionTypeArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionTypeArrayInput` via: // @@ -710,6 +813,12 @@ func (i CustomResourceDefinitionTypeArray) ToCustomResourceDefinitionTypeArrayOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionTypeArrayOutput) } +func (i CustomResourceDefinitionTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionType] { + return pulumix.Output[[]CustomResourceDefinitionType]{ + OutputState: i.ToCustomResourceDefinitionTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. type CustomResourceDefinitionTypeOutput struct{ *pulumi.OutputState } @@ -725,6 +834,12 @@ func (o CustomResourceDefinitionTypeOutput) ToCustomResourceDefinitionTypeOutput return o } +func (o CustomResourceDefinitionTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionType] { + return pulumix.Output[CustomResourceDefinitionType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -764,6 +879,12 @@ func (o CustomResourceDefinitionTypeArrayOutput) ToCustomResourceDefinitionTypeA return o } +func (o CustomResourceDefinitionTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionType] { + return pulumix.Output[[]CustomResourceDefinitionType]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionTypeArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionType { return vs[0].([]CustomResourceDefinitionType)[vs[1].(int)] @@ -821,6 +942,12 @@ func (i CustomResourceDefinitionConditionArgs) ToCustomResourceDefinitionConditi return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionOutput) } +func (i CustomResourceDefinitionConditionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionCondition] { + return pulumix.Output[CustomResourceDefinitionCondition]{ + OutputState: i.ToCustomResourceDefinitionConditionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionConditionArrayInput is an input type that accepts CustomResourceDefinitionConditionArray and CustomResourceDefinitionConditionArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionConditionArrayInput` via: // @@ -846,6 +973,12 @@ func (i CustomResourceDefinitionConditionArray) ToCustomResourceDefinitionCondit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionArrayOutput) } +func (i CustomResourceDefinitionConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionCondition] { + return pulumix.Output[[]CustomResourceDefinitionCondition]{ + OutputState: i.ToCustomResourceDefinitionConditionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionCondition contains details for the current condition of this pod. type CustomResourceDefinitionConditionOutput struct{ *pulumi.OutputState } @@ -861,6 +994,12 @@ func (o CustomResourceDefinitionConditionOutput) ToCustomResourceDefinitionCondi return o } +func (o CustomResourceDefinitionConditionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionCondition] { + return pulumix.Output[CustomResourceDefinitionCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime last time the condition transitioned from one status to another. func (o CustomResourceDefinitionConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -900,6 +1039,12 @@ func (o CustomResourceDefinitionConditionArrayOutput) ToCustomResourceDefinition return o } +func (o CustomResourceDefinitionConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionCondition] { + return pulumix.Output[[]CustomResourceDefinitionCondition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionConditionArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionCondition { return vs[0].([]CustomResourceDefinitionCondition)[vs[1].(int)] @@ -957,6 +1102,12 @@ func (i CustomResourceDefinitionConditionPatchArgs) ToCustomResourceDefinitionCo return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionPatchOutput) } +func (i CustomResourceDefinitionConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionConditionPatch] { + return pulumix.Output[CustomResourceDefinitionConditionPatch]{ + OutputState: i.ToCustomResourceDefinitionConditionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionConditionPatchArrayInput is an input type that accepts CustomResourceDefinitionConditionPatchArray and CustomResourceDefinitionConditionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionConditionPatchArrayInput` via: // @@ -982,6 +1133,12 @@ func (i CustomResourceDefinitionConditionPatchArray) ToCustomResourceDefinitionC return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionPatchArrayOutput) } +func (i CustomResourceDefinitionConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionConditionPatch] { + return pulumix.Output[[]CustomResourceDefinitionConditionPatch]{ + OutputState: i.ToCustomResourceDefinitionConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionCondition contains details for the current condition of this pod. type CustomResourceDefinitionConditionPatchOutput struct{ *pulumi.OutputState } @@ -997,6 +1154,12 @@ func (o CustomResourceDefinitionConditionPatchOutput) ToCustomResourceDefinition return o } +func (o CustomResourceDefinitionConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionConditionPatch] { + return pulumix.Output[CustomResourceDefinitionConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime last time the condition transitioned from one status to another. func (o CustomResourceDefinitionConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -1036,6 +1199,12 @@ func (o CustomResourceDefinitionConditionPatchArrayOutput) ToCustomResourceDefin return o } +func (o CustomResourceDefinitionConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionConditionPatch] { + return pulumix.Output[[]CustomResourceDefinitionConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionConditionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionConditionPatch { return vs[0].([]CustomResourceDefinitionConditionPatch)[vs[1].(int)] @@ -1089,6 +1258,12 @@ func (i CustomResourceDefinitionListTypeArgs) ToCustomResourceDefinitionListType return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListTypeOutput) } +func (i CustomResourceDefinitionListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionListType] { + return pulumix.Output[CustomResourceDefinitionListType]{ + OutputState: i.ToCustomResourceDefinitionListTypeOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionList is a list of CustomResourceDefinition objects. type CustomResourceDefinitionListTypeOutput struct{ *pulumi.OutputState } @@ -1104,6 +1279,12 @@ func (o CustomResourceDefinitionListTypeOutput) ToCustomResourceDefinitionListTy return o } +func (o CustomResourceDefinitionListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionListType] { + return pulumix.Output[CustomResourceDefinitionListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1179,6 +1360,12 @@ func (i CustomResourceDefinitionNamesArgs) ToCustomResourceDefinitionNamesOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesOutput) } +func (i CustomResourceDefinitionNamesArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNames] { + return pulumix.Output[CustomResourceDefinitionNames]{ + OutputState: i.ToCustomResourceDefinitionNamesOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionNamesArgs) ToCustomResourceDefinitionNamesPtrOutput() CustomResourceDefinitionNamesPtrOutput { return i.ToCustomResourceDefinitionNamesPtrOutputWithContext(context.Background()) } @@ -1220,6 +1407,12 @@ func (i *customResourceDefinitionNamesPtrType) ToCustomResourceDefinitionNamesPt return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesPtrOutput) } +func (i *customResourceDefinitionNamesPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNames] { + return pulumix.Output[*CustomResourceDefinitionNames]{ + OutputState: i.ToCustomResourceDefinitionNamesPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition type CustomResourceDefinitionNamesOutput struct{ *pulumi.OutputState } @@ -1245,6 +1438,12 @@ func (o CustomResourceDefinitionNamesOutput) ToCustomResourceDefinitionNamesPtrO }).(CustomResourceDefinitionNamesPtrOutput) } +func (o CustomResourceDefinitionNamesOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNames] { + return pulumix.Output[CustomResourceDefinitionNames]{ + OutputState: o.OutputState, + } +} + // categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. func (o CustomResourceDefinitionNamesOutput) Categories() pulumi.StringArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionNames) []string { return v.Categories }).(pulumi.StringArrayOutput) @@ -1289,6 +1488,12 @@ func (o CustomResourceDefinitionNamesPtrOutput) ToCustomResourceDefinitionNamesP return o } +func (o CustomResourceDefinitionNamesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNames] { + return pulumix.Output[*CustomResourceDefinitionNames]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionNamesPtrOutput) Elem() CustomResourceDefinitionNamesOutput { return o.ApplyT(func(v *CustomResourceDefinitionNames) CustomResourceDefinitionNames { if v != nil { @@ -1414,6 +1619,12 @@ func (i CustomResourceDefinitionNamesPatchArgs) ToCustomResourceDefinitionNamesP return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesPatchOutput) } +func (i CustomResourceDefinitionNamesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNamesPatch] { + return pulumix.Output[CustomResourceDefinitionNamesPatch]{ + OutputState: i.ToCustomResourceDefinitionNamesPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionNamesPatchArgs) ToCustomResourceDefinitionNamesPatchPtrOutput() CustomResourceDefinitionNamesPatchPtrOutput { return i.ToCustomResourceDefinitionNamesPatchPtrOutputWithContext(context.Background()) } @@ -1455,6 +1666,12 @@ func (i *customResourceDefinitionNamesPatchPtrType) ToCustomResourceDefinitionNa return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesPatchPtrOutput) } +func (i *customResourceDefinitionNamesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNamesPatch] { + return pulumix.Output[*CustomResourceDefinitionNamesPatch]{ + OutputState: i.ToCustomResourceDefinitionNamesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition type CustomResourceDefinitionNamesPatchOutput struct{ *pulumi.OutputState } @@ -1480,6 +1697,12 @@ func (o CustomResourceDefinitionNamesPatchOutput) ToCustomResourceDefinitionName }).(CustomResourceDefinitionNamesPatchPtrOutput) } +func (o CustomResourceDefinitionNamesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNamesPatch] { + return pulumix.Output[CustomResourceDefinitionNamesPatch]{ + OutputState: o.OutputState, + } +} + // categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. func (o CustomResourceDefinitionNamesPatchOutput) Categories() pulumi.StringArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionNamesPatch) []string { return v.Categories }).(pulumi.StringArrayOutput) @@ -1524,6 +1747,12 @@ func (o CustomResourceDefinitionNamesPatchPtrOutput) ToCustomResourceDefinitionN return o } +func (o CustomResourceDefinitionNamesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNamesPatch] { + return pulumix.Output[*CustomResourceDefinitionNamesPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionNamesPatchPtrOutput) Elem() CustomResourceDefinitionNamesPatchOutput { return o.ApplyT(func(v *CustomResourceDefinitionNamesPatch) CustomResourceDefinitionNamesPatch { if v != nil { @@ -1645,6 +1874,12 @@ func (i CustomResourceDefinitionPatchTypeArgs) ToCustomResourceDefinitionPatchTy return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchTypeOutput) } +func (i CustomResourceDefinitionPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionPatchType] { + return pulumix.Output[CustomResourceDefinitionPatchType]{ + OutputState: i.ToCustomResourceDefinitionPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. type CustomResourceDefinitionPatchTypeOutput struct{ *pulumi.OutputState } @@ -1660,6 +1895,12 @@ func (o CustomResourceDefinitionPatchTypeOutput) ToCustomResourceDefinitionPatch return o } +func (o CustomResourceDefinitionPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionPatchType] { + return pulumix.Output[CustomResourceDefinitionPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1740,6 +1981,12 @@ func (i CustomResourceDefinitionSpecArgs) ToCustomResourceDefinitionSpecOutputWi return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionSpecOutput) } +func (i CustomResourceDefinitionSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpec] { + return pulumix.Output[CustomResourceDefinitionSpec]{ + OutputState: i.ToCustomResourceDefinitionSpecOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionSpec describes how a user wants their resource to appear type CustomResourceDefinitionSpecOutput struct{ *pulumi.OutputState } @@ -1755,6 +2002,12 @@ func (o CustomResourceDefinitionSpecOutput) ToCustomResourceDefinitionSpecOutput return o } +func (o CustomResourceDefinitionSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpec] { + return pulumix.Output[CustomResourceDefinitionSpec]{ + OutputState: o.OutputState, + } +} + // conversion defines conversion settings for the CRD. func (o CustomResourceDefinitionSpecOutput) Conversion() CustomResourceConversionPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionSpec) *CustomResourceConversion { return v.Conversion }).(CustomResourceConversionPtrOutput) @@ -1840,6 +2093,12 @@ func (i CustomResourceDefinitionSpecPatchArgs) ToCustomResourceDefinitionSpecPat return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionSpecPatchOutput) } +func (i CustomResourceDefinitionSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpecPatch] { + return pulumix.Output[CustomResourceDefinitionSpecPatch]{ + OutputState: i.ToCustomResourceDefinitionSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionSpecPatchArgs) ToCustomResourceDefinitionSpecPatchPtrOutput() CustomResourceDefinitionSpecPatchPtrOutput { return i.ToCustomResourceDefinitionSpecPatchPtrOutputWithContext(context.Background()) } @@ -1881,6 +2140,12 @@ func (i *customResourceDefinitionSpecPatchPtrType) ToCustomResourceDefinitionSpe return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionSpecPatchPtrOutput) } +func (i *customResourceDefinitionSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionSpecPatch] { + return pulumix.Output[*CustomResourceDefinitionSpecPatch]{ + OutputState: i.ToCustomResourceDefinitionSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionSpec describes how a user wants their resource to appear type CustomResourceDefinitionSpecPatchOutput struct{ *pulumi.OutputState } @@ -1906,6 +2171,12 @@ func (o CustomResourceDefinitionSpecPatchOutput) ToCustomResourceDefinitionSpecP }).(CustomResourceDefinitionSpecPatchPtrOutput) } +func (o CustomResourceDefinitionSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpecPatch] { + return pulumix.Output[CustomResourceDefinitionSpecPatch]{ + OutputState: o.OutputState, + } +} + // conversion defines conversion settings for the CRD. func (o CustomResourceDefinitionSpecPatchOutput) Conversion() CustomResourceConversionPatchPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionSpecPatch) *CustomResourceConversionPatch { return v.Conversion }).(CustomResourceConversionPatchPtrOutput) @@ -1950,6 +2221,12 @@ func (o CustomResourceDefinitionSpecPatchPtrOutput) ToCustomResourceDefinitionSp return o } +func (o CustomResourceDefinitionSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionSpecPatch] { + return pulumix.Output[*CustomResourceDefinitionSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionSpecPatchPtrOutput) Elem() CustomResourceDefinitionSpecPatchOutput { return o.ApplyT(func(v *CustomResourceDefinitionSpecPatch) CustomResourceDefinitionSpecPatch { if v != nil { @@ -2063,6 +2340,12 @@ func (i CustomResourceDefinitionStatusArgs) ToCustomResourceDefinitionStatusOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusOutput) } +func (i CustomResourceDefinitionStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatus] { + return pulumix.Output[CustomResourceDefinitionStatus]{ + OutputState: i.ToCustomResourceDefinitionStatusOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionStatusArgs) ToCustomResourceDefinitionStatusPtrOutput() CustomResourceDefinitionStatusPtrOutput { return i.ToCustomResourceDefinitionStatusPtrOutputWithContext(context.Background()) } @@ -2104,6 +2387,12 @@ func (i *customResourceDefinitionStatusPtrType) ToCustomResourceDefinitionStatus return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusPtrOutput) } +func (i *customResourceDefinitionStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatus] { + return pulumix.Output[*CustomResourceDefinitionStatus]{ + OutputState: i.ToCustomResourceDefinitionStatusPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition type CustomResourceDefinitionStatusOutput struct{ *pulumi.OutputState } @@ -2129,6 +2418,12 @@ func (o CustomResourceDefinitionStatusOutput) ToCustomResourceDefinitionStatusPt }).(CustomResourceDefinitionStatusPtrOutput) } +func (o CustomResourceDefinitionStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatus] { + return pulumix.Output[CustomResourceDefinitionStatus]{ + OutputState: o.OutputState, + } +} + // acceptedNames are the names that are actually being used to serve discovery. They may be different than the names in spec. func (o CustomResourceDefinitionStatusOutput) AcceptedNames() CustomResourceDefinitionNamesOutput { return o.ApplyT(func(v CustomResourceDefinitionStatus) CustomResourceDefinitionNames { return v.AcceptedNames }).(CustomResourceDefinitionNamesOutput) @@ -2158,6 +2453,12 @@ func (o CustomResourceDefinitionStatusPtrOutput) ToCustomResourceDefinitionStatu return o } +func (o CustomResourceDefinitionStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatus] { + return pulumix.Output[*CustomResourceDefinitionStatus]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionStatusPtrOutput) Elem() CustomResourceDefinitionStatusOutput { return o.ApplyT(func(v *CustomResourceDefinitionStatus) CustomResourceDefinitionStatus { if v != nil { @@ -2241,6 +2542,12 @@ func (i CustomResourceDefinitionStatusPatchArgs) ToCustomResourceDefinitionStatu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusPatchOutput) } +func (i CustomResourceDefinitionStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatusPatch] { + return pulumix.Output[CustomResourceDefinitionStatusPatch]{ + OutputState: i.ToCustomResourceDefinitionStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionStatusPatchArgs) ToCustomResourceDefinitionStatusPatchPtrOutput() CustomResourceDefinitionStatusPatchPtrOutput { return i.ToCustomResourceDefinitionStatusPatchPtrOutputWithContext(context.Background()) } @@ -2282,6 +2589,12 @@ func (i *customResourceDefinitionStatusPatchPtrType) ToCustomResourceDefinitionS return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusPatchPtrOutput) } +func (i *customResourceDefinitionStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatusPatch] { + return pulumix.Output[*CustomResourceDefinitionStatusPatch]{ + OutputState: i.ToCustomResourceDefinitionStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition type CustomResourceDefinitionStatusPatchOutput struct{ *pulumi.OutputState } @@ -2307,6 +2620,12 @@ func (o CustomResourceDefinitionStatusPatchOutput) ToCustomResourceDefinitionSta }).(CustomResourceDefinitionStatusPatchPtrOutput) } +func (o CustomResourceDefinitionStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatusPatch] { + return pulumix.Output[CustomResourceDefinitionStatusPatch]{ + OutputState: o.OutputState, + } +} + // acceptedNames are the names that are actually being used to serve discovery. They may be different than the names in spec. func (o CustomResourceDefinitionStatusPatchOutput) AcceptedNames() CustomResourceDefinitionNamesPatchPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionStatusPatch) *CustomResourceDefinitionNamesPatch { @@ -2340,6 +2659,12 @@ func (o CustomResourceDefinitionStatusPatchPtrOutput) ToCustomResourceDefinition return o } +func (o CustomResourceDefinitionStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatusPatch] { + return pulumix.Output[*CustomResourceDefinitionStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionStatusPatchPtrOutput) Elem() CustomResourceDefinitionStatusPatchOutput { return o.ApplyT(func(v *CustomResourceDefinitionStatusPatch) CustomResourceDefinitionStatusPatch { if v != nil { @@ -2443,6 +2768,12 @@ func (i CustomResourceDefinitionVersionArgs) ToCustomResourceDefinitionVersionOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionOutput) } +func (i CustomResourceDefinitionVersionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersion] { + return pulumix.Output[CustomResourceDefinitionVersion]{ + OutputState: i.ToCustomResourceDefinitionVersionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersionArrayInput is an input type that accepts CustomResourceDefinitionVersionArray and CustomResourceDefinitionVersionArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionVersionArrayInput` via: // @@ -2468,6 +2799,12 @@ func (i CustomResourceDefinitionVersionArray) ToCustomResourceDefinitionVersionA return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionArrayOutput) } +func (i CustomResourceDefinitionVersionArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersion] { + return pulumix.Output[[]CustomResourceDefinitionVersion]{ + OutputState: i.ToCustomResourceDefinitionVersionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersion describes a version for CRD. type CustomResourceDefinitionVersionOutput struct{ *pulumi.OutputState } @@ -2483,6 +2820,12 @@ func (o CustomResourceDefinitionVersionOutput) ToCustomResourceDefinitionVersion return o } +func (o CustomResourceDefinitionVersionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersion] { + return pulumix.Output[CustomResourceDefinitionVersion]{ + OutputState: o.OutputState, + } +} + // additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If no columns are specified, a single column displaying the age of the custom resource is used. func (o CustomResourceDefinitionVersionOutput) AdditionalPrinterColumns() CustomResourceColumnDefinitionArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionVersion) []CustomResourceColumnDefinition { @@ -2539,6 +2882,12 @@ func (o CustomResourceDefinitionVersionArrayOutput) ToCustomResourceDefinitionVe return o } +func (o CustomResourceDefinitionVersionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersion] { + return pulumix.Output[[]CustomResourceDefinitionVersion]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionVersionArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionVersionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionVersion { return vs[0].([]CustomResourceDefinitionVersion)[vs[1].(int)] @@ -2608,6 +2957,12 @@ func (i CustomResourceDefinitionVersionPatchArgs) ToCustomResourceDefinitionVers return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionPatchOutput) } +func (i CustomResourceDefinitionVersionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersionPatch] { + return pulumix.Output[CustomResourceDefinitionVersionPatch]{ + OutputState: i.ToCustomResourceDefinitionVersionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersionPatchArrayInput is an input type that accepts CustomResourceDefinitionVersionPatchArray and CustomResourceDefinitionVersionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionVersionPatchArrayInput` via: // @@ -2633,6 +2988,12 @@ func (i CustomResourceDefinitionVersionPatchArray) ToCustomResourceDefinitionVer return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionPatchArrayOutput) } +func (i CustomResourceDefinitionVersionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersionPatch] { + return pulumix.Output[[]CustomResourceDefinitionVersionPatch]{ + OutputState: i.ToCustomResourceDefinitionVersionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersion describes a version for CRD. type CustomResourceDefinitionVersionPatchOutput struct{ *pulumi.OutputState } @@ -2648,6 +3009,12 @@ func (o CustomResourceDefinitionVersionPatchOutput) ToCustomResourceDefinitionVe return o } +func (o CustomResourceDefinitionVersionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersionPatch] { + return pulumix.Output[CustomResourceDefinitionVersionPatch]{ + OutputState: o.OutputState, + } +} + // additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If no columns are specified, a single column displaying the age of the custom resource is used. func (o CustomResourceDefinitionVersionPatchOutput) AdditionalPrinterColumns() CustomResourceColumnDefinitionPatchArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionVersionPatch) []CustomResourceColumnDefinitionPatch { @@ -2704,6 +3071,12 @@ func (o CustomResourceDefinitionVersionPatchArrayOutput) ToCustomResourceDefinit return o } +func (o CustomResourceDefinitionVersionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersionPatch] { + return pulumix.Output[[]CustomResourceDefinitionVersionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionVersionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionVersionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionVersionPatch { return vs[0].([]CustomResourceDefinitionVersionPatch)[vs[1].(int)] @@ -2753,6 +3126,12 @@ func (i CustomResourceSubresourceScaleArgs) ToCustomResourceSubresourceScaleOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScaleOutput) } +func (i CustomResourceSubresourceScaleArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScale] { + return pulumix.Output[CustomResourceSubresourceScale]{ + OutputState: i.ToCustomResourceSubresourceScaleOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourceScaleArgs) ToCustomResourceSubresourceScalePtrOutput() CustomResourceSubresourceScalePtrOutput { return i.ToCustomResourceSubresourceScalePtrOutputWithContext(context.Background()) } @@ -2794,6 +3173,12 @@ func (i *customResourceSubresourceScalePtrType) ToCustomResourceSubresourceScale return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScalePtrOutput) } +func (i *customResourceSubresourceScalePtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScale] { + return pulumix.Output[*CustomResourceSubresourceScale]{ + OutputState: i.ToCustomResourceSubresourceScalePtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources. type CustomResourceSubresourceScaleOutput struct{ *pulumi.OutputState } @@ -2819,6 +3204,12 @@ func (o CustomResourceSubresourceScaleOutput) ToCustomResourceSubresourceScalePt }).(CustomResourceSubresourceScalePtrOutput) } +func (o CustomResourceSubresourceScaleOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScale] { + return pulumix.Output[CustomResourceSubresourceScale]{ + OutputState: o.OutputState, + } +} + // labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. func (o CustomResourceSubresourceScaleOutput) LabelSelectorPath() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceSubresourceScale) *string { return v.LabelSelectorPath }).(pulumi.StringPtrOutput) @@ -2848,6 +3239,12 @@ func (o CustomResourceSubresourceScalePtrOutput) ToCustomResourceSubresourceScal return o } +func (o CustomResourceSubresourceScalePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScale] { + return pulumix.Output[*CustomResourceSubresourceScale]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourceScalePtrOutput) Elem() CustomResourceSubresourceScaleOutput { return o.ApplyT(func(v *CustomResourceSubresourceScale) CustomResourceSubresourceScale { if v != nil { @@ -2931,6 +3328,12 @@ func (i CustomResourceSubresourceScalePatchArgs) ToCustomResourceSubresourceScal return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScalePatchOutput) } +func (i CustomResourceSubresourceScalePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScalePatch] { + return pulumix.Output[CustomResourceSubresourceScalePatch]{ + OutputState: i.ToCustomResourceSubresourceScalePatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourceScalePatchArgs) ToCustomResourceSubresourceScalePatchPtrOutput() CustomResourceSubresourceScalePatchPtrOutput { return i.ToCustomResourceSubresourceScalePatchPtrOutputWithContext(context.Background()) } @@ -2972,6 +3375,12 @@ func (i *customResourceSubresourceScalePatchPtrType) ToCustomResourceSubresource return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScalePatchPtrOutput) } +func (i *customResourceSubresourceScalePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScalePatch] { + return pulumix.Output[*CustomResourceSubresourceScalePatch]{ + OutputState: i.ToCustomResourceSubresourceScalePatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources. type CustomResourceSubresourceScalePatchOutput struct{ *pulumi.OutputState } @@ -2997,6 +3406,12 @@ func (o CustomResourceSubresourceScalePatchOutput) ToCustomResourceSubresourceSc }).(CustomResourceSubresourceScalePatchPtrOutput) } +func (o CustomResourceSubresourceScalePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScalePatch] { + return pulumix.Output[CustomResourceSubresourceScalePatch]{ + OutputState: o.OutputState, + } +} + // labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. func (o CustomResourceSubresourceScalePatchOutput) LabelSelectorPath() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceSubresourceScalePatch) *string { return v.LabelSelectorPath }).(pulumi.StringPtrOutput) @@ -3026,6 +3441,12 @@ func (o CustomResourceSubresourceScalePatchPtrOutput) ToCustomResourceSubresourc return o } +func (o CustomResourceSubresourceScalePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScalePatch] { + return pulumix.Output[*CustomResourceSubresourceScalePatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourceScalePatchPtrOutput) Elem() CustomResourceSubresourceScalePatchOutput { return o.ApplyT(func(v *CustomResourceSubresourceScalePatch) CustomResourceSubresourceScalePatch { if v != nil { @@ -3105,6 +3526,12 @@ func (i CustomResourceSubresourcesArgs) ToCustomResourceSubresourcesOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesOutput) } +func (i CustomResourceSubresourcesArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresources] { + return pulumix.Output[CustomResourceSubresources]{ + OutputState: i.ToCustomResourceSubresourcesOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourcesArgs) ToCustomResourceSubresourcesPtrOutput() CustomResourceSubresourcesPtrOutput { return i.ToCustomResourceSubresourcesPtrOutputWithContext(context.Background()) } @@ -3146,6 +3573,12 @@ func (i *customResourceSubresourcesPtrType) ToCustomResourceSubresourcesPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesPtrOutput) } +func (i *customResourceSubresourcesPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresources] { + return pulumix.Output[*CustomResourceSubresources]{ + OutputState: i.ToCustomResourceSubresourcesPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresources defines the status and scale subresources for CustomResources. type CustomResourceSubresourcesOutput struct{ *pulumi.OutputState } @@ -3171,6 +3604,12 @@ func (o CustomResourceSubresourcesOutput) ToCustomResourceSubresourcesPtrOutputW }).(CustomResourceSubresourcesPtrOutput) } +func (o CustomResourceSubresourcesOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresources] { + return pulumix.Output[CustomResourceSubresources]{ + OutputState: o.OutputState, + } +} + // scale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object. func (o CustomResourceSubresourcesOutput) Scale() CustomResourceSubresourceScalePtrOutput { return o.ApplyT(func(v CustomResourceSubresources) *CustomResourceSubresourceScale { return v.Scale }).(CustomResourceSubresourceScalePtrOutput) @@ -3195,6 +3634,12 @@ func (o CustomResourceSubresourcesPtrOutput) ToCustomResourceSubresourcesPtrOutp return o } +func (o CustomResourceSubresourcesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresources] { + return pulumix.Output[*CustomResourceSubresources]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourcesPtrOutput) Elem() CustomResourceSubresourcesOutput { return o.ApplyT(func(v *CustomResourceSubresources) CustomResourceSubresources { if v != nil { @@ -3264,6 +3709,12 @@ func (i CustomResourceSubresourcesPatchArgs) ToCustomResourceSubresourcesPatchOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesPatchOutput) } +func (i CustomResourceSubresourcesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourcesPatch] { + return pulumix.Output[CustomResourceSubresourcesPatch]{ + OutputState: i.ToCustomResourceSubresourcesPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourcesPatchArgs) ToCustomResourceSubresourcesPatchPtrOutput() CustomResourceSubresourcesPatchPtrOutput { return i.ToCustomResourceSubresourcesPatchPtrOutputWithContext(context.Background()) } @@ -3305,6 +3756,12 @@ func (i *customResourceSubresourcesPatchPtrType) ToCustomResourceSubresourcesPat return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesPatchPtrOutput) } +func (i *customResourceSubresourcesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourcesPatch] { + return pulumix.Output[*CustomResourceSubresourcesPatch]{ + OutputState: i.ToCustomResourceSubresourcesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresources defines the status and scale subresources for CustomResources. type CustomResourceSubresourcesPatchOutput struct{ *pulumi.OutputState } @@ -3330,6 +3787,12 @@ func (o CustomResourceSubresourcesPatchOutput) ToCustomResourceSubresourcesPatch }).(CustomResourceSubresourcesPatchPtrOutput) } +func (o CustomResourceSubresourcesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourcesPatch] { + return pulumix.Output[CustomResourceSubresourcesPatch]{ + OutputState: o.OutputState, + } +} + // scale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object. func (o CustomResourceSubresourcesPatchOutput) Scale() CustomResourceSubresourceScalePatchPtrOutput { return o.ApplyT(func(v CustomResourceSubresourcesPatch) *CustomResourceSubresourceScalePatch { return v.Scale }).(CustomResourceSubresourceScalePatchPtrOutput) @@ -3354,6 +3817,12 @@ func (o CustomResourceSubresourcesPatchPtrOutput) ToCustomResourceSubresourcesPa return o } +func (o CustomResourceSubresourcesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourcesPatch] { + return pulumix.Output[*CustomResourceSubresourcesPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourcesPatchPtrOutput) Elem() CustomResourceSubresourcesPatchOutput { return o.ApplyT(func(v *CustomResourceSubresourcesPatch) CustomResourceSubresourcesPatch { if v != nil { @@ -3419,6 +3888,12 @@ func (i CustomResourceValidationArgs) ToCustomResourceValidationOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationOutput) } +func (i CustomResourceValidationArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidation] { + return pulumix.Output[CustomResourceValidation]{ + OutputState: i.ToCustomResourceValidationOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceValidationArgs) ToCustomResourceValidationPtrOutput() CustomResourceValidationPtrOutput { return i.ToCustomResourceValidationPtrOutputWithContext(context.Background()) } @@ -3460,6 +3935,12 @@ func (i *customResourceValidationPtrType) ToCustomResourceValidationPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationPtrOutput) } +func (i *customResourceValidationPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidation] { + return pulumix.Output[*CustomResourceValidation]{ + OutputState: i.ToCustomResourceValidationPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceValidation is a list of validation methods for CustomResources. type CustomResourceValidationOutput struct{ *pulumi.OutputState } @@ -3485,6 +3966,12 @@ func (o CustomResourceValidationOutput) ToCustomResourceValidationPtrOutputWithC }).(CustomResourceValidationPtrOutput) } +func (o CustomResourceValidationOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidation] { + return pulumix.Output[CustomResourceValidation]{ + OutputState: o.OutputState, + } +} + // openAPIV3Schema is the OpenAPI v3 schema to use for validation and pruning. func (o CustomResourceValidationOutput) OpenAPIV3Schema() JSONSchemaPropsPtrOutput { return o.ApplyT(func(v CustomResourceValidation) *JSONSchemaProps { return v.OpenAPIV3Schema }).(JSONSchemaPropsPtrOutput) @@ -3504,6 +3991,12 @@ func (o CustomResourceValidationPtrOutput) ToCustomResourceValidationPtrOutputWi return o } +func (o CustomResourceValidationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidation] { + return pulumix.Output[*CustomResourceValidation]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceValidationPtrOutput) Elem() CustomResourceValidationOutput { return o.ApplyT(func(v *CustomResourceValidation) CustomResourceValidation { if v != nil { @@ -3559,6 +4052,12 @@ func (i CustomResourceValidationPatchArgs) ToCustomResourceValidationPatchOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationPatchOutput) } +func (i CustomResourceValidationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidationPatch] { + return pulumix.Output[CustomResourceValidationPatch]{ + OutputState: i.ToCustomResourceValidationPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceValidationPatchArgs) ToCustomResourceValidationPatchPtrOutput() CustomResourceValidationPatchPtrOutput { return i.ToCustomResourceValidationPatchPtrOutputWithContext(context.Background()) } @@ -3600,6 +4099,12 @@ func (i *customResourceValidationPatchPtrType) ToCustomResourceValidationPatchPt return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationPatchPtrOutput) } +func (i *customResourceValidationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidationPatch] { + return pulumix.Output[*CustomResourceValidationPatch]{ + OutputState: i.ToCustomResourceValidationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceValidation is a list of validation methods for CustomResources. type CustomResourceValidationPatchOutput struct{ *pulumi.OutputState } @@ -3625,6 +4130,12 @@ func (o CustomResourceValidationPatchOutput) ToCustomResourceValidationPatchPtrO }).(CustomResourceValidationPatchPtrOutput) } +func (o CustomResourceValidationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidationPatch] { + return pulumix.Output[CustomResourceValidationPatch]{ + OutputState: o.OutputState, + } +} + // openAPIV3Schema is the OpenAPI v3 schema to use for validation and pruning. func (o CustomResourceValidationPatchOutput) OpenAPIV3Schema() JSONSchemaPropsPatchPtrOutput { return o.ApplyT(func(v CustomResourceValidationPatch) *JSONSchemaPropsPatch { return v.OpenAPIV3Schema }).(JSONSchemaPropsPatchPtrOutput) @@ -3644,6 +4155,12 @@ func (o CustomResourceValidationPatchPtrOutput) ToCustomResourceValidationPatchP return o } +func (o CustomResourceValidationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidationPatch] { + return pulumix.Output[*CustomResourceValidationPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceValidationPatchPtrOutput) Elem() CustomResourceValidationPatchOutput { return o.ApplyT(func(v *CustomResourceValidationPatch) CustomResourceValidationPatch { if v != nil { @@ -3699,6 +4216,12 @@ func (i ExternalDocumentationArgs) ToExternalDocumentationOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationOutput) } +func (i ExternalDocumentationArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentation] { + return pulumix.Output[ExternalDocumentation]{ + OutputState: i.ToExternalDocumentationOutputWithContext(ctx).OutputState, + } +} + func (i ExternalDocumentationArgs) ToExternalDocumentationPtrOutput() ExternalDocumentationPtrOutput { return i.ToExternalDocumentationPtrOutputWithContext(context.Background()) } @@ -3740,6 +4263,12 @@ func (i *externalDocumentationPtrType) ToExternalDocumentationPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationPtrOutput) } +func (i *externalDocumentationPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentation] { + return pulumix.Output[*ExternalDocumentation]{ + OutputState: i.ToExternalDocumentationPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalDocumentation allows referencing an external resource for extended documentation. type ExternalDocumentationOutput struct{ *pulumi.OutputState } @@ -3765,6 +4294,12 @@ func (o ExternalDocumentationOutput) ToExternalDocumentationPtrOutputWithContext }).(ExternalDocumentationPtrOutput) } +func (o ExternalDocumentationOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentation] { + return pulumix.Output[ExternalDocumentation]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalDocumentation) *string { return v.Description }).(pulumi.StringPtrOutput) } @@ -3787,6 +4322,12 @@ func (o ExternalDocumentationPtrOutput) ToExternalDocumentationPtrOutputWithCont return o } +func (o ExternalDocumentationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentation] { + return pulumix.Output[*ExternalDocumentation]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationPtrOutput) Elem() ExternalDocumentationOutput { return o.ApplyT(func(v *ExternalDocumentation) ExternalDocumentation { if v != nil { @@ -3850,6 +4391,12 @@ func (i ExternalDocumentationPatchArgs) ToExternalDocumentationPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationPatchOutput) } +func (i ExternalDocumentationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentationPatch] { + return pulumix.Output[ExternalDocumentationPatch]{ + OutputState: i.ToExternalDocumentationPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalDocumentationPatchArgs) ToExternalDocumentationPatchPtrOutput() ExternalDocumentationPatchPtrOutput { return i.ToExternalDocumentationPatchPtrOutputWithContext(context.Background()) } @@ -3891,6 +4438,12 @@ func (i *externalDocumentationPatchPtrType) ToExternalDocumentationPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationPatchPtrOutput) } +func (i *externalDocumentationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentationPatch] { + return pulumix.Output[*ExternalDocumentationPatch]{ + OutputState: i.ToExternalDocumentationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalDocumentation allows referencing an external resource for extended documentation. type ExternalDocumentationPatchOutput struct{ *pulumi.OutputState } @@ -3916,6 +4469,12 @@ func (o ExternalDocumentationPatchOutput) ToExternalDocumentationPatchPtrOutputW }).(ExternalDocumentationPatchPtrOutput) } +func (o ExternalDocumentationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentationPatch] { + return pulumix.Output[ExternalDocumentationPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationPatchOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalDocumentationPatch) *string { return v.Description }).(pulumi.StringPtrOutput) } @@ -3938,6 +4497,12 @@ func (o ExternalDocumentationPatchPtrOutput) ToExternalDocumentationPatchPtrOutp return o } +func (o ExternalDocumentationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentationPatch] { + return pulumix.Output[*ExternalDocumentationPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationPatchPtrOutput) Elem() ExternalDocumentationPatchOutput { return o.ApplyT(func(v *ExternalDocumentationPatch) ExternalDocumentationPatch { if v != nil { @@ -4173,6 +4738,12 @@ func (i JSONSchemaPropsArgs) ToJSONSchemaPropsOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsOutput) } +func (i JSONSchemaPropsArgs) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaProps] { + return pulumix.Output[JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsOutputWithContext(ctx).OutputState, + } +} + func (i JSONSchemaPropsArgs) ToJSONSchemaPropsPtrOutput() JSONSchemaPropsPtrOutput { return i.ToJSONSchemaPropsPtrOutputWithContext(context.Background()) } @@ -4214,6 +4785,12 @@ func (i *jsonschemaPropsPtrType) ToJSONSchemaPropsPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPtrOutput) } +func (i *jsonschemaPropsPtrType) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaProps] { + return pulumix.Output[*JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsPtrOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaPropsArrayInput is an input type that accepts JSONSchemaPropsArray and JSONSchemaPropsArrayOutput values. // You can construct a concrete instance of `JSONSchemaPropsArrayInput` via: // @@ -4239,6 +4816,12 @@ func (i JSONSchemaPropsArray) ToJSONSchemaPropsArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsArrayOutput) } +func (i JSONSchemaPropsArray) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaProps] { + return pulumix.Output[[]JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsArrayOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaPropsMapInput is an input type that accepts JSONSchemaPropsMap and JSONSchemaPropsMapOutput values. // You can construct a concrete instance of `JSONSchemaPropsMapInput` via: // @@ -4264,6 +4847,12 @@ func (i JSONSchemaPropsMap) ToJSONSchemaPropsMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsMapOutput) } +func (i JSONSchemaPropsMap) ToOutput(ctx context.Context) pulumix.Output[map[string]JSONSchemaProps] { + return pulumix.Output[map[string]JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsMapOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). type JSONSchemaPropsOutput struct{ *pulumi.OutputState } @@ -4289,6 +4878,12 @@ func (o JSONSchemaPropsOutput) ToJSONSchemaPropsPtrOutputWithContext(ctx context }).(JSONSchemaPropsPtrOutput) } +func (o JSONSchemaPropsOutput) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaProps] { + return pulumix.Output[JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsOutput) Ref() pulumi.StringPtrOutput { return o.ApplyT(func(v JSONSchemaProps) *string { return v.Ref }).(pulumi.StringPtrOutput) } @@ -4524,6 +5119,12 @@ func (o JSONSchemaPropsPtrOutput) ToJSONSchemaPropsPtrOutputWithContext(ctx cont return o } +func (o JSONSchemaPropsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaProps] { + return pulumix.Output[*JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPtrOutput) Elem() JSONSchemaPropsOutput { return o.ApplyT(func(v *JSONSchemaProps) JSONSchemaProps { if v != nil { @@ -4989,6 +5590,12 @@ func (o JSONSchemaPropsArrayOutput) ToJSONSchemaPropsArrayOutputWithContext(ctx return o } +func (o JSONSchemaPropsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaProps] { + return pulumix.Output[[]JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsArrayOutput) Index(i pulumi.IntInput) JSONSchemaPropsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JSONSchemaProps { return vs[0].([]JSONSchemaProps)[vs[1].(int)] @@ -5009,6 +5616,12 @@ func (o JSONSchemaPropsMapOutput) ToJSONSchemaPropsMapOutputWithContext(ctx cont return o } +func (o JSONSchemaPropsMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]JSONSchemaProps] { + return pulumix.Output[map[string]JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsMapOutput) MapIndex(k pulumi.StringInput) JSONSchemaPropsOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) JSONSchemaProps { return vs[0].(map[string]JSONSchemaProps)[vs[1].(string)] @@ -5222,6 +5835,12 @@ func (i JSONSchemaPropsPatchArgs) ToJSONSchemaPropsPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPatchOutput) } +func (i JSONSchemaPropsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaPropsPatch] { + return pulumix.Output[JSONSchemaPropsPatch]{ + OutputState: i.ToJSONSchemaPropsPatchOutputWithContext(ctx).OutputState, + } +} + func (i JSONSchemaPropsPatchArgs) ToJSONSchemaPropsPatchPtrOutput() JSONSchemaPropsPatchPtrOutput { return i.ToJSONSchemaPropsPatchPtrOutputWithContext(context.Background()) } @@ -5263,6 +5882,12 @@ func (i *jsonschemaPropsPatchPtrType) ToJSONSchemaPropsPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPatchPtrOutput) } +func (i *jsonschemaPropsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaPropsPatch] { + return pulumix.Output[*JSONSchemaPropsPatch]{ + OutputState: i.ToJSONSchemaPropsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaPropsPatchArrayInput is an input type that accepts JSONSchemaPropsPatchArray and JSONSchemaPropsPatchArrayOutput values. // You can construct a concrete instance of `JSONSchemaPropsPatchArrayInput` via: // @@ -5288,6 +5913,12 @@ func (i JSONSchemaPropsPatchArray) ToJSONSchemaPropsPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPatchArrayOutput) } +func (i JSONSchemaPropsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaPropsPatch] { + return pulumix.Output[[]JSONSchemaPropsPatch]{ + OutputState: i.ToJSONSchemaPropsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). type JSONSchemaPropsPatchOutput struct{ *pulumi.OutputState } @@ -5313,6 +5944,12 @@ func (o JSONSchemaPropsPatchOutput) ToJSONSchemaPropsPatchPtrOutputWithContext(c }).(JSONSchemaPropsPatchPtrOutput) } +func (o JSONSchemaPropsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaPropsPatch] { + return pulumix.Output[JSONSchemaPropsPatch]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPatchOutput) Ref() pulumi.StringPtrOutput { return o.ApplyT(func(v JSONSchemaPropsPatch) *string { return v.Ref }).(pulumi.StringPtrOutput) } @@ -5548,6 +6185,12 @@ func (o JSONSchemaPropsPatchPtrOutput) ToJSONSchemaPropsPatchPtrOutputWithContex return o } +func (o JSONSchemaPropsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaPropsPatch] { + return pulumix.Output[*JSONSchemaPropsPatch]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPatchPtrOutput) Elem() JSONSchemaPropsPatchOutput { return o.ApplyT(func(v *JSONSchemaPropsPatch) JSONSchemaPropsPatch { if v != nil { @@ -6013,6 +6656,12 @@ func (o JSONSchemaPropsPatchArrayOutput) ToJSONSchemaPropsPatchArrayOutputWithCo return o } +func (o JSONSchemaPropsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaPropsPatch] { + return pulumix.Output[[]JSONSchemaPropsPatch]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPatchArrayOutput) Index(i pulumi.IntInput) JSONSchemaPropsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JSONSchemaPropsPatch { return vs[0].([]JSONSchemaPropsPatch)[vs[1].(int)] @@ -6066,6 +6715,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -6107,6 +6762,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -6132,6 +6793,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // name is the name of the service. Required func (o ServiceReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceReference) string { return v.Name }).(pulumi.StringOutput) @@ -6166,6 +6833,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -6263,6 +6936,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -6304,6 +6983,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -6329,6 +7014,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the service. Required func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -6363,6 +7054,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { @@ -6512,6 +7209,12 @@ func (i ValidationRuleArgs) ToValidationRuleOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ValidationRuleOutput) } +func (i ValidationRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ValidationRule] { + return pulumix.Output[ValidationRule]{ + OutputState: i.ToValidationRuleOutputWithContext(ctx).OutputState, + } +} + // ValidationRuleArrayInput is an input type that accepts ValidationRuleArray and ValidationRuleArrayOutput values. // You can construct a concrete instance of `ValidationRuleArrayInput` via: // @@ -6537,6 +7240,12 @@ func (i ValidationRuleArray) ToValidationRuleArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ValidationRuleArrayOutput) } +func (i ValidationRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidationRule] { + return pulumix.Output[[]ValidationRule]{ + OutputState: i.ToValidationRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ValidationRule describes a validation rule written in the CEL expression language. type ValidationRuleOutput struct{ *pulumi.OutputState } @@ -6552,6 +7261,12 @@ func (o ValidationRuleOutput) ToValidationRuleOutputWithContext(ctx context.Cont return o } +func (o ValidationRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ValidationRule] { + return pulumix.Output[ValidationRule]{ + OutputState: o.OutputState, + } +} + // fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']` func (o ValidationRuleOutput) FieldPath() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidationRule) *string { return v.FieldPath }).(pulumi.StringPtrOutput) @@ -6617,6 +7332,12 @@ func (o ValidationRuleArrayOutput) ToValidationRuleArrayOutputWithContext(ctx co return o } +func (o ValidationRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidationRule] { + return pulumix.Output[[]ValidationRule]{ + OutputState: o.OutputState, + } +} + func (o ValidationRuleArrayOutput) Index(i pulumi.IntInput) ValidationRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidationRule { return vs[0].([]ValidationRule)[vs[1].(int)] @@ -6722,6 +7443,12 @@ func (i ValidationRulePatchArgs) ToValidationRulePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ValidationRulePatchOutput) } +func (i ValidationRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ValidationRulePatch] { + return pulumix.Output[ValidationRulePatch]{ + OutputState: i.ToValidationRulePatchOutputWithContext(ctx).OutputState, + } +} + // ValidationRulePatchArrayInput is an input type that accepts ValidationRulePatchArray and ValidationRulePatchArrayOutput values. // You can construct a concrete instance of `ValidationRulePatchArrayInput` via: // @@ -6747,6 +7474,12 @@ func (i ValidationRulePatchArray) ToValidationRulePatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ValidationRulePatchArrayOutput) } +func (i ValidationRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ValidationRulePatch] { + return pulumix.Output[[]ValidationRulePatch]{ + OutputState: i.ToValidationRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ValidationRule describes a validation rule written in the CEL expression language. type ValidationRulePatchOutput struct{ *pulumi.OutputState } @@ -6762,6 +7495,12 @@ func (o ValidationRulePatchOutput) ToValidationRulePatchOutputWithContext(ctx co return o } +func (o ValidationRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ValidationRulePatch] { + return pulumix.Output[ValidationRulePatch]{ + OutputState: o.OutputState, + } +} + // fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']` func (o ValidationRulePatchOutput) FieldPath() pulumi.StringPtrOutput { return o.ApplyT(func(v ValidationRulePatch) *string { return v.FieldPath }).(pulumi.StringPtrOutput) @@ -6827,6 +7566,12 @@ func (o ValidationRulePatchArrayOutput) ToValidationRulePatchArrayOutputWithCont return o } +func (o ValidationRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ValidationRulePatch] { + return pulumix.Output[[]ValidationRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ValidationRulePatchArrayOutput) Index(i pulumi.IntInput) ValidationRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ValidationRulePatch { return vs[0].([]ValidationRulePatch)[vs[1].(int)] @@ -6900,6 +7645,12 @@ func (i WebhookClientConfigArgs) ToWebhookClientConfigOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigOutput) } +func (i WebhookClientConfigArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigArgs) ToWebhookClientConfigPtrOutput() WebhookClientConfigPtrOutput { return i.ToWebhookClientConfigPtrOutputWithContext(context.Background()) } @@ -6941,6 +7692,12 @@ func (i *webhookClientConfigPtrType) ToWebhookClientConfigPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPtrOutput) } +func (i *webhookClientConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfig] { + return pulumix.Output[*WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook. type WebhookClientConfigOutput struct{ *pulumi.OutputState } @@ -6966,6 +7723,12 @@ func (o WebhookClientConfigOutput) ToWebhookClientConfigPtrOutputWithContext(ctx }).(WebhookClientConfigPtrOutput) } +func (o WebhookClientConfigOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + // caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfig) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -7007,6 +7770,12 @@ func (o WebhookClientConfigPtrOutput) ToWebhookClientConfigPtrOutputWithContext( return o } +func (o WebhookClientConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfig] { + return pulumix.Output[*WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPtrOutput) Elem() WebhookClientConfigOutput { return o.ApplyT(func(v *WebhookClientConfig) WebhookClientConfig { if v != nil { @@ -7126,6 +7895,12 @@ func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchOutput) } +func (i WebhookClientConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchPtrOutput() WebhookClientConfigPatchPtrOutput { return i.ToWebhookClientConfigPatchPtrOutputWithContext(context.Background()) } @@ -7167,6 +7942,12 @@ func (i *webhookClientConfigPatchPtrType) ToWebhookClientConfigPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchPtrOutput) } +func (i *webhookClientConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook. type WebhookClientConfigPatchOutput struct{ *pulumi.OutputState } @@ -7192,6 +7973,12 @@ func (o WebhookClientConfigPatchOutput) ToWebhookClientConfigPatchPtrOutputWithC }).(WebhookClientConfigPatchPtrOutput) } +func (o WebhookClientConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + // caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfigPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -7233,6 +8020,12 @@ func (o WebhookClientConfigPatchPtrOutput) ToWebhookClientConfigPatchPtrOutputWi return o } +func (o WebhookClientConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPatchPtrOutput) Elem() WebhookClientConfigPatchOutput { return o.ApplyT(func(v *WebhookClientConfigPatch) WebhookClientConfigPatch { if v != nil { @@ -7324,6 +8117,12 @@ func (i WebhookConversionArgs) ToWebhookConversionOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(WebhookConversionOutput) } +func (i WebhookConversionArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookConversion] { + return pulumix.Output[WebhookConversion]{ + OutputState: i.ToWebhookConversionOutputWithContext(ctx).OutputState, + } +} + func (i WebhookConversionArgs) ToWebhookConversionPtrOutput() WebhookConversionPtrOutput { return i.ToWebhookConversionPtrOutputWithContext(context.Background()) } @@ -7365,6 +8164,12 @@ func (i *webhookConversionPtrType) ToWebhookConversionPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(WebhookConversionPtrOutput) } +func (i *webhookConversionPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookConversion] { + return pulumix.Output[*WebhookConversion]{ + OutputState: i.ToWebhookConversionPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookConversion describes how to call a conversion webhook type WebhookConversionOutput struct{ *pulumi.OutputState } @@ -7390,6 +8195,12 @@ func (o WebhookConversionOutput) ToWebhookConversionPtrOutputWithContext(ctx con }).(WebhookConversionPtrOutput) } +func (o WebhookConversionOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookConversion] { + return pulumix.Output[WebhookConversion]{ + OutputState: o.OutputState, + } +} + // clientConfig is the instructions for how to call the webhook if strategy is `Webhook`. func (o WebhookConversionOutput) ClientConfig() WebhookClientConfigPtrOutput { return o.ApplyT(func(v WebhookConversion) *WebhookClientConfig { return v.ClientConfig }).(WebhookClientConfigPtrOutput) @@ -7414,6 +8225,12 @@ func (o WebhookConversionPtrOutput) ToWebhookConversionPtrOutputWithContext(ctx return o } +func (o WebhookConversionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookConversion] { + return pulumix.Output[*WebhookConversion]{ + OutputState: o.OutputState, + } +} + func (o WebhookConversionPtrOutput) Elem() WebhookConversionOutput { return o.ApplyT(func(v *WebhookConversion) WebhookConversion { if v != nil { @@ -7483,6 +8300,12 @@ func (i WebhookConversionPatchArgs) ToWebhookConversionPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(WebhookConversionPatchOutput) } +func (i WebhookConversionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookConversionPatch] { + return pulumix.Output[WebhookConversionPatch]{ + OutputState: i.ToWebhookConversionPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookConversionPatchArgs) ToWebhookConversionPatchPtrOutput() WebhookConversionPatchPtrOutput { return i.ToWebhookConversionPatchPtrOutputWithContext(context.Background()) } @@ -7524,6 +8347,12 @@ func (i *webhookConversionPatchPtrType) ToWebhookConversionPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(WebhookConversionPatchPtrOutput) } +func (i *webhookConversionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookConversionPatch] { + return pulumix.Output[*WebhookConversionPatch]{ + OutputState: i.ToWebhookConversionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookConversion describes how to call a conversion webhook type WebhookConversionPatchOutput struct{ *pulumi.OutputState } @@ -7549,6 +8378,12 @@ func (o WebhookConversionPatchOutput) ToWebhookConversionPatchPtrOutputWithConte }).(WebhookConversionPatchPtrOutput) } +func (o WebhookConversionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookConversionPatch] { + return pulumix.Output[WebhookConversionPatch]{ + OutputState: o.OutputState, + } +} + // clientConfig is the instructions for how to call the webhook if strategy is `Webhook`. func (o WebhookConversionPatchOutput) ClientConfig() WebhookClientConfigPatchPtrOutput { return o.ApplyT(func(v WebhookConversionPatch) *WebhookClientConfigPatch { return v.ClientConfig }).(WebhookClientConfigPatchPtrOutput) @@ -7573,6 +8408,12 @@ func (o WebhookConversionPatchPtrOutput) ToWebhookConversionPatchPtrOutputWithCo return o } +func (o WebhookConversionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookConversionPatch] { + return pulumix.Output[*WebhookConversionPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookConversionPatchPtrOutput) Elem() WebhookConversionPatchOutput { return o.ApplyT(func(v *WebhookConversionPatch) WebhookConversionPatch { if v != nil { diff --git a/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinition.go b/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinition.go index 3d8f739860..ab382457c1 100644 --- a/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinition.go +++ b/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinition.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. Deprecated in v1.16, planned for removal in v1.19. Use apiextensions.k8s.io/v1 CustomResourceDefinition instead. @@ -122,6 +123,12 @@ func (i *CustomResourceDefinition) ToCustomResourceDefinitionOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionOutput) } +func (i *CustomResourceDefinition) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinition] { + return pulumix.Output[*CustomResourceDefinition]{ + OutputState: i.ToCustomResourceDefinitionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionArrayInput is an input type that accepts CustomResourceDefinitionArray and CustomResourceDefinitionArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionArrayInput` via: // @@ -147,6 +154,12 @@ func (i CustomResourceDefinitionArray) ToCustomResourceDefinitionArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionArrayOutput) } +func (i CustomResourceDefinitionArray) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinition] { + return pulumix.Output[[]*CustomResourceDefinition]{ + OutputState: i.ToCustomResourceDefinitionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionMapInput is an input type that accepts CustomResourceDefinitionMap and CustomResourceDefinitionMapOutput values. // You can construct a concrete instance of `CustomResourceDefinitionMapInput` via: // @@ -172,6 +185,12 @@ func (i CustomResourceDefinitionMap) ToCustomResourceDefinitionMapOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionMapOutput) } +func (i CustomResourceDefinitionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinition] { + return pulumix.Output[map[string]*CustomResourceDefinition]{ + OutputState: i.ToCustomResourceDefinitionMapOutputWithContext(ctx).OutputState, + } +} + type CustomResourceDefinitionOutput struct{ *pulumi.OutputState } func (CustomResourceDefinitionOutput) ElementType() reflect.Type { @@ -186,6 +205,12 @@ func (o CustomResourceDefinitionOutput) ToCustomResourceDefinitionOutputWithCont return o } +func (o CustomResourceDefinitionOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinition] { + return pulumix.Output[*CustomResourceDefinition]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CustomResourceDefinition) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o CustomResourceDefinitionArrayOutput) ToCustomResourceDefinitionArrayOutp return o } +func (o CustomResourceDefinitionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinition] { + return pulumix.Output[[]*CustomResourceDefinition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CustomResourceDefinition { return vs[0].([]*CustomResourceDefinition)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o CustomResourceDefinitionMapOutput) ToCustomResourceDefinitionMapOutputWi return o } +func (o CustomResourceDefinitionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinition] { + return pulumix.Output[map[string]*CustomResourceDefinition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionMapOutput) MapIndex(k pulumi.StringInput) CustomResourceDefinitionOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CustomResourceDefinition { return vs[0].(map[string]*CustomResourceDefinition)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionList.go b/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionList.go index 4196d1d863..5da8593aa4 100644 --- a/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionList.go +++ b/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CustomResourceDefinitionList is a list of CustomResourceDefinition objects. @@ -114,6 +115,12 @@ func (i *CustomResourceDefinitionList) ToCustomResourceDefinitionListOutputWithC return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListOutput) } +func (i *CustomResourceDefinitionList) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionList] { + return pulumix.Output[*CustomResourceDefinitionList]{ + OutputState: i.ToCustomResourceDefinitionListOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionListArrayInput is an input type that accepts CustomResourceDefinitionListArray and CustomResourceDefinitionListArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionListArrayInput` via: // @@ -139,6 +146,12 @@ func (i CustomResourceDefinitionListArray) ToCustomResourceDefinitionListArrayOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListArrayOutput) } +func (i CustomResourceDefinitionListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionList] { + return pulumix.Output[[]*CustomResourceDefinitionList]{ + OutputState: i.ToCustomResourceDefinitionListArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionListMapInput is an input type that accepts CustomResourceDefinitionListMap and CustomResourceDefinitionListMapOutput values. // You can construct a concrete instance of `CustomResourceDefinitionListMapInput` via: // @@ -164,6 +177,12 @@ func (i CustomResourceDefinitionListMap) ToCustomResourceDefinitionListMapOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListMapOutput) } +func (i CustomResourceDefinitionListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionList] { + return pulumix.Output[map[string]*CustomResourceDefinitionList]{ + OutputState: i.ToCustomResourceDefinitionListMapOutputWithContext(ctx).OutputState, + } +} + type CustomResourceDefinitionListOutput struct{ *pulumi.OutputState } func (CustomResourceDefinitionListOutput) ElementType() reflect.Type { @@ -178,6 +197,12 @@ func (o CustomResourceDefinitionListOutput) ToCustomResourceDefinitionListOutput return o } +func (o CustomResourceDefinitionListOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionList] { + return pulumix.Output[*CustomResourceDefinitionList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CustomResourceDefinitionList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o CustomResourceDefinitionListArrayOutput) ToCustomResourceDefinitionListA return o } +func (o CustomResourceDefinitionListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionList] { + return pulumix.Output[[]*CustomResourceDefinitionList]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionListArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CustomResourceDefinitionList { return vs[0].([]*CustomResourceDefinitionList)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o CustomResourceDefinitionListMapOutput) ToCustomResourceDefinitionListMap return o } +func (o CustomResourceDefinitionListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionList] { + return pulumix.Output[map[string]*CustomResourceDefinitionList]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionListMapOutput) MapIndex(k pulumi.StringInput) CustomResourceDefinitionListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CustomResourceDefinitionList { return vs[0].(map[string]*CustomResourceDefinitionList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionPatch.go b/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionPatch.go index 8e5afe85c8..fb886a065b 100644 --- a/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionPatch.go +++ b/sdk/go/kubernetes/apiextensions/v1beta1/customResourceDefinitionPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -124,6 +125,12 @@ func (i *CustomResourceDefinitionPatch) ToCustomResourceDefinitionPatchOutputWit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchOutput) } +func (i *CustomResourceDefinitionPatch) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionPatch] { + return pulumix.Output[*CustomResourceDefinitionPatch]{ + OutputState: i.ToCustomResourceDefinitionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionPatchArrayInput is an input type that accepts CustomResourceDefinitionPatchArray and CustomResourceDefinitionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionPatchArrayInput` via: // @@ -149,6 +156,12 @@ func (i CustomResourceDefinitionPatchArray) ToCustomResourceDefinitionPatchArray return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchArrayOutput) } +func (i CustomResourceDefinitionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionPatch] { + return pulumix.Output[[]*CustomResourceDefinitionPatch]{ + OutputState: i.ToCustomResourceDefinitionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionPatchMapInput is an input type that accepts CustomResourceDefinitionPatchMap and CustomResourceDefinitionPatchMapOutput values. // You can construct a concrete instance of `CustomResourceDefinitionPatchMapInput` via: // @@ -174,6 +187,12 @@ func (i CustomResourceDefinitionPatchMap) ToCustomResourceDefinitionPatchMapOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchMapOutput) } +func (i CustomResourceDefinitionPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionPatch] { + return pulumix.Output[map[string]*CustomResourceDefinitionPatch]{ + OutputState: i.ToCustomResourceDefinitionPatchMapOutputWithContext(ctx).OutputState, + } +} + type CustomResourceDefinitionPatchOutput struct{ *pulumi.OutputState } func (CustomResourceDefinitionPatchOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o CustomResourceDefinitionPatchOutput) ToCustomResourceDefinitionPatchOutp return o } +func (o CustomResourceDefinitionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionPatch] { + return pulumix.Output[*CustomResourceDefinitionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CustomResourceDefinitionPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o CustomResourceDefinitionPatchArrayOutput) ToCustomResourceDefinitionPatc return o } +func (o CustomResourceDefinitionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CustomResourceDefinitionPatch] { + return pulumix.Output[[]*CustomResourceDefinitionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CustomResourceDefinitionPatch { return vs[0].([]*CustomResourceDefinitionPatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o CustomResourceDefinitionPatchMapOutput) ToCustomResourceDefinitionPatchM return o } +func (o CustomResourceDefinitionPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CustomResourceDefinitionPatch] { + return pulumix.Output[map[string]*CustomResourceDefinitionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionPatchMapOutput) MapIndex(k pulumi.StringInput) CustomResourceDefinitionPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CustomResourceDefinitionPatch { return vs[0].(map[string]*CustomResourceDefinitionPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiextensions/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/apiextensions/v1beta1/pulumiTypes.go index e6d7e441d2..52891373e1 100644 --- a/sdk/go/kubernetes/apiextensions/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/apiextensions/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -69,6 +70,12 @@ func (i CustomResourceColumnDefinitionArgs) ToCustomResourceColumnDefinitionOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionOutput) } +func (i CustomResourceColumnDefinitionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinition] { + return pulumix.Output[CustomResourceColumnDefinition]{ + OutputState: i.ToCustomResourceColumnDefinitionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinitionArrayInput is an input type that accepts CustomResourceColumnDefinitionArray and CustomResourceColumnDefinitionArrayOutput values. // You can construct a concrete instance of `CustomResourceColumnDefinitionArrayInput` via: // @@ -94,6 +101,12 @@ func (i CustomResourceColumnDefinitionArray) ToCustomResourceColumnDefinitionArr return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionArrayOutput) } +func (i CustomResourceColumnDefinitionArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinition] { + return pulumix.Output[[]CustomResourceColumnDefinition]{ + OutputState: i.ToCustomResourceColumnDefinitionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinition specifies a column for server side printing. type CustomResourceColumnDefinitionOutput struct{ *pulumi.OutputState } @@ -109,6 +122,12 @@ func (o CustomResourceColumnDefinitionOutput) ToCustomResourceColumnDefinitionOu return o } +func (o CustomResourceColumnDefinitionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinition] { + return pulumix.Output[CustomResourceColumnDefinition]{ + OutputState: o.OutputState, + } +} + // JSONPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column. func (o CustomResourceColumnDefinitionOutput) JSONPath() pulumi.StringOutput { return o.ApplyT(func(v CustomResourceColumnDefinition) string { return v.JSONPath }).(pulumi.StringOutput) @@ -153,6 +172,12 @@ func (o CustomResourceColumnDefinitionArrayOutput) ToCustomResourceColumnDefinit return o } +func (o CustomResourceColumnDefinitionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinition] { + return pulumix.Output[[]CustomResourceColumnDefinition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceColumnDefinitionArrayOutput) Index(i pulumi.IntInput) CustomResourceColumnDefinitionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceColumnDefinition { return vs[0].([]CustomResourceColumnDefinition)[vs[1].(int)] @@ -214,6 +239,12 @@ func (i CustomResourceColumnDefinitionPatchArgs) ToCustomResourceColumnDefinitio return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionPatchOutput) } +func (i CustomResourceColumnDefinitionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinitionPatch] { + return pulumix.Output[CustomResourceColumnDefinitionPatch]{ + OutputState: i.ToCustomResourceColumnDefinitionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinitionPatchArrayInput is an input type that accepts CustomResourceColumnDefinitionPatchArray and CustomResourceColumnDefinitionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceColumnDefinitionPatchArrayInput` via: // @@ -239,6 +270,12 @@ func (i CustomResourceColumnDefinitionPatchArray) ToCustomResourceColumnDefiniti return pulumi.ToOutputWithContext(ctx, i).(CustomResourceColumnDefinitionPatchArrayOutput) } +func (i CustomResourceColumnDefinitionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinitionPatch] { + return pulumix.Output[[]CustomResourceColumnDefinitionPatch]{ + OutputState: i.ToCustomResourceColumnDefinitionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceColumnDefinition specifies a column for server side printing. type CustomResourceColumnDefinitionPatchOutput struct{ *pulumi.OutputState } @@ -254,6 +291,12 @@ func (o CustomResourceColumnDefinitionPatchOutput) ToCustomResourceColumnDefinit return o } +func (o CustomResourceColumnDefinitionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceColumnDefinitionPatch] { + return pulumix.Output[CustomResourceColumnDefinitionPatch]{ + OutputState: o.OutputState, + } +} + // JSONPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column. func (o CustomResourceColumnDefinitionPatchOutput) JSONPath() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceColumnDefinitionPatch) *string { return v.JSONPath }).(pulumi.StringPtrOutput) @@ -298,6 +341,12 @@ func (o CustomResourceColumnDefinitionPatchArrayOutput) ToCustomResourceColumnDe return o } +func (o CustomResourceColumnDefinitionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceColumnDefinitionPatch] { + return pulumix.Output[[]CustomResourceColumnDefinitionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceColumnDefinitionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceColumnDefinitionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceColumnDefinitionPatch { return vs[0].([]CustomResourceColumnDefinitionPatch)[vs[1].(int)] @@ -349,6 +398,12 @@ func (i CustomResourceConversionArgs) ToCustomResourceConversionOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionOutput) } +func (i CustomResourceConversionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversion] { + return pulumix.Output[CustomResourceConversion]{ + OutputState: i.ToCustomResourceConversionOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceConversionArgs) ToCustomResourceConversionPtrOutput() CustomResourceConversionPtrOutput { return i.ToCustomResourceConversionPtrOutputWithContext(context.Background()) } @@ -390,6 +445,12 @@ func (i *customResourceConversionPtrType) ToCustomResourceConversionPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionPtrOutput) } +func (i *customResourceConversionPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversion] { + return pulumix.Output[*CustomResourceConversion]{ + OutputState: i.ToCustomResourceConversionPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceConversion describes how to convert different versions of a CR. type CustomResourceConversionOutput struct{ *pulumi.OutputState } @@ -415,6 +476,12 @@ func (o CustomResourceConversionOutput) ToCustomResourceConversionPtrOutputWithC }).(CustomResourceConversionPtrOutput) } +func (o CustomResourceConversionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversion] { + return pulumix.Output[CustomResourceConversion]{ + OutputState: o.OutputState, + } +} + // conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail. Defaults to `["v1beta1"]`. func (o CustomResourceConversionOutput) ConversionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v CustomResourceConversion) []string { return v.ConversionReviewVersions }).(pulumi.StringArrayOutput) @@ -446,6 +513,12 @@ func (o CustomResourceConversionPtrOutput) ToCustomResourceConversionPtrOutputWi return o } +func (o CustomResourceConversionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversion] { + return pulumix.Output[*CustomResourceConversion]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceConversionPtrOutput) Elem() CustomResourceConversionOutput { return o.ApplyT(func(v *CustomResourceConversion) CustomResourceConversion { if v != nil { @@ -533,6 +606,12 @@ func (i CustomResourceConversionPatchArgs) ToCustomResourceConversionPatchOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionPatchOutput) } +func (i CustomResourceConversionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversionPatch] { + return pulumix.Output[CustomResourceConversionPatch]{ + OutputState: i.ToCustomResourceConversionPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceConversionPatchArgs) ToCustomResourceConversionPatchPtrOutput() CustomResourceConversionPatchPtrOutput { return i.ToCustomResourceConversionPatchPtrOutputWithContext(context.Background()) } @@ -574,6 +653,12 @@ func (i *customResourceConversionPatchPtrType) ToCustomResourceConversionPatchPt return pulumi.ToOutputWithContext(ctx, i).(CustomResourceConversionPatchPtrOutput) } +func (i *customResourceConversionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversionPatch] { + return pulumix.Output[*CustomResourceConversionPatch]{ + OutputState: i.ToCustomResourceConversionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceConversion describes how to convert different versions of a CR. type CustomResourceConversionPatchOutput struct{ *pulumi.OutputState } @@ -599,6 +684,12 @@ func (o CustomResourceConversionPatchOutput) ToCustomResourceConversionPatchPtrO }).(CustomResourceConversionPatchPtrOutput) } +func (o CustomResourceConversionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceConversionPatch] { + return pulumix.Output[CustomResourceConversionPatch]{ + OutputState: o.OutputState, + } +} + // conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail. Defaults to `["v1beta1"]`. func (o CustomResourceConversionPatchOutput) ConversionReviewVersions() pulumi.StringArrayOutput { return o.ApplyT(func(v CustomResourceConversionPatch) []string { return v.ConversionReviewVersions }).(pulumi.StringArrayOutput) @@ -630,6 +721,12 @@ func (o CustomResourceConversionPatchPtrOutput) ToCustomResourceConversionPatchP return o } +func (o CustomResourceConversionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceConversionPatch] { + return pulumix.Output[*CustomResourceConversionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceConversionPatchPtrOutput) Elem() CustomResourceConversionPatchOutput { return o.ApplyT(func(v *CustomResourceConversionPatch) CustomResourceConversionPatch { if v != nil { @@ -721,6 +818,12 @@ func (i CustomResourceDefinitionTypeArgs) ToCustomResourceDefinitionTypeOutputWi return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionTypeOutput) } +func (i CustomResourceDefinitionTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionType] { + return pulumix.Output[CustomResourceDefinitionType]{ + OutputState: i.ToCustomResourceDefinitionTypeOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionTypeArrayInput is an input type that accepts CustomResourceDefinitionTypeArray and CustomResourceDefinitionTypeArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionTypeArrayInput` via: // @@ -746,6 +849,12 @@ func (i CustomResourceDefinitionTypeArray) ToCustomResourceDefinitionTypeArrayOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionTypeArrayOutput) } +func (i CustomResourceDefinitionTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionType] { + return pulumix.Output[[]CustomResourceDefinitionType]{ + OutputState: i.ToCustomResourceDefinitionTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. Deprecated in v1.16, planned for removal in v1.19. Use apiextensions.k8s.io/v1 CustomResourceDefinition instead. type CustomResourceDefinitionTypeOutput struct{ *pulumi.OutputState } @@ -761,6 +870,12 @@ func (o CustomResourceDefinitionTypeOutput) ToCustomResourceDefinitionTypeOutput return o } +func (o CustomResourceDefinitionTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionType] { + return pulumix.Output[CustomResourceDefinitionType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -799,6 +914,12 @@ func (o CustomResourceDefinitionTypeArrayOutput) ToCustomResourceDefinitionTypeA return o } +func (o CustomResourceDefinitionTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionType] { + return pulumix.Output[[]CustomResourceDefinitionType]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionTypeArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionType { return vs[0].([]CustomResourceDefinitionType)[vs[1].(int)] @@ -856,6 +977,12 @@ func (i CustomResourceDefinitionConditionArgs) ToCustomResourceDefinitionConditi return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionOutput) } +func (i CustomResourceDefinitionConditionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionCondition] { + return pulumix.Output[CustomResourceDefinitionCondition]{ + OutputState: i.ToCustomResourceDefinitionConditionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionConditionArrayInput is an input type that accepts CustomResourceDefinitionConditionArray and CustomResourceDefinitionConditionArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionConditionArrayInput` via: // @@ -881,6 +1008,12 @@ func (i CustomResourceDefinitionConditionArray) ToCustomResourceDefinitionCondit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionArrayOutput) } +func (i CustomResourceDefinitionConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionCondition] { + return pulumix.Output[[]CustomResourceDefinitionCondition]{ + OutputState: i.ToCustomResourceDefinitionConditionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionCondition contains details for the current condition of this pod. type CustomResourceDefinitionConditionOutput struct{ *pulumi.OutputState } @@ -896,6 +1029,12 @@ func (o CustomResourceDefinitionConditionOutput) ToCustomResourceDefinitionCondi return o } +func (o CustomResourceDefinitionConditionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionCondition] { + return pulumix.Output[CustomResourceDefinitionCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime last time the condition transitioned from one status to another. func (o CustomResourceDefinitionConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -935,6 +1074,12 @@ func (o CustomResourceDefinitionConditionArrayOutput) ToCustomResourceDefinition return o } +func (o CustomResourceDefinitionConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionCondition] { + return pulumix.Output[[]CustomResourceDefinitionCondition]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionConditionArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionCondition { return vs[0].([]CustomResourceDefinitionCondition)[vs[1].(int)] @@ -992,6 +1137,12 @@ func (i CustomResourceDefinitionConditionPatchArgs) ToCustomResourceDefinitionCo return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionPatchOutput) } +func (i CustomResourceDefinitionConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionConditionPatch] { + return pulumix.Output[CustomResourceDefinitionConditionPatch]{ + OutputState: i.ToCustomResourceDefinitionConditionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionConditionPatchArrayInput is an input type that accepts CustomResourceDefinitionConditionPatchArray and CustomResourceDefinitionConditionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionConditionPatchArrayInput` via: // @@ -1017,6 +1168,12 @@ func (i CustomResourceDefinitionConditionPatchArray) ToCustomResourceDefinitionC return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionConditionPatchArrayOutput) } +func (i CustomResourceDefinitionConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionConditionPatch] { + return pulumix.Output[[]CustomResourceDefinitionConditionPatch]{ + OutputState: i.ToCustomResourceDefinitionConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionCondition contains details for the current condition of this pod. type CustomResourceDefinitionConditionPatchOutput struct{ *pulumi.OutputState } @@ -1032,6 +1189,12 @@ func (o CustomResourceDefinitionConditionPatchOutput) ToCustomResourceDefinition return o } +func (o CustomResourceDefinitionConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionConditionPatch] { + return pulumix.Output[CustomResourceDefinitionConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime last time the condition transitioned from one status to another. func (o CustomResourceDefinitionConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -1071,6 +1234,12 @@ func (o CustomResourceDefinitionConditionPatchArrayOutput) ToCustomResourceDefin return o } +func (o CustomResourceDefinitionConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionConditionPatch] { + return pulumix.Output[[]CustomResourceDefinitionConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionConditionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionConditionPatch { return vs[0].([]CustomResourceDefinitionConditionPatch)[vs[1].(int)] @@ -1122,6 +1291,12 @@ func (i CustomResourceDefinitionListTypeArgs) ToCustomResourceDefinitionListType return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionListTypeOutput) } +func (i CustomResourceDefinitionListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionListType] { + return pulumix.Output[CustomResourceDefinitionListType]{ + OutputState: i.ToCustomResourceDefinitionListTypeOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionList is a list of CustomResourceDefinition objects. type CustomResourceDefinitionListTypeOutput struct{ *pulumi.OutputState } @@ -1137,6 +1312,12 @@ func (o CustomResourceDefinitionListTypeOutput) ToCustomResourceDefinitionListTy return o } +func (o CustomResourceDefinitionListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionListType] { + return pulumix.Output[CustomResourceDefinitionListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1211,6 +1392,12 @@ func (i CustomResourceDefinitionNamesArgs) ToCustomResourceDefinitionNamesOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesOutput) } +func (i CustomResourceDefinitionNamesArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNames] { + return pulumix.Output[CustomResourceDefinitionNames]{ + OutputState: i.ToCustomResourceDefinitionNamesOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionNamesArgs) ToCustomResourceDefinitionNamesPtrOutput() CustomResourceDefinitionNamesPtrOutput { return i.ToCustomResourceDefinitionNamesPtrOutputWithContext(context.Background()) } @@ -1252,6 +1439,12 @@ func (i *customResourceDefinitionNamesPtrType) ToCustomResourceDefinitionNamesPt return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesPtrOutput) } +func (i *customResourceDefinitionNamesPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNames] { + return pulumix.Output[*CustomResourceDefinitionNames]{ + OutputState: i.ToCustomResourceDefinitionNamesPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition type CustomResourceDefinitionNamesOutput struct{ *pulumi.OutputState } @@ -1277,6 +1470,12 @@ func (o CustomResourceDefinitionNamesOutput) ToCustomResourceDefinitionNamesPtrO }).(CustomResourceDefinitionNamesPtrOutput) } +func (o CustomResourceDefinitionNamesOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNames] { + return pulumix.Output[CustomResourceDefinitionNames]{ + OutputState: o.OutputState, + } +} + // categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. func (o CustomResourceDefinitionNamesOutput) Categories() pulumi.StringArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionNames) []string { return v.Categories }).(pulumi.StringArrayOutput) @@ -1321,6 +1520,12 @@ func (o CustomResourceDefinitionNamesPtrOutput) ToCustomResourceDefinitionNamesP return o } +func (o CustomResourceDefinitionNamesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNames] { + return pulumix.Output[*CustomResourceDefinitionNames]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionNamesPtrOutput) Elem() CustomResourceDefinitionNamesOutput { return o.ApplyT(func(v *CustomResourceDefinitionNames) CustomResourceDefinitionNames { if v != nil { @@ -1446,6 +1651,12 @@ func (i CustomResourceDefinitionNamesPatchArgs) ToCustomResourceDefinitionNamesP return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesPatchOutput) } +func (i CustomResourceDefinitionNamesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNamesPatch] { + return pulumix.Output[CustomResourceDefinitionNamesPatch]{ + OutputState: i.ToCustomResourceDefinitionNamesPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionNamesPatchArgs) ToCustomResourceDefinitionNamesPatchPtrOutput() CustomResourceDefinitionNamesPatchPtrOutput { return i.ToCustomResourceDefinitionNamesPatchPtrOutputWithContext(context.Background()) } @@ -1487,6 +1698,12 @@ func (i *customResourceDefinitionNamesPatchPtrType) ToCustomResourceDefinitionNa return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionNamesPatchPtrOutput) } +func (i *customResourceDefinitionNamesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNamesPatch] { + return pulumix.Output[*CustomResourceDefinitionNamesPatch]{ + OutputState: i.ToCustomResourceDefinitionNamesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition type CustomResourceDefinitionNamesPatchOutput struct{ *pulumi.OutputState } @@ -1512,6 +1729,12 @@ func (o CustomResourceDefinitionNamesPatchOutput) ToCustomResourceDefinitionName }).(CustomResourceDefinitionNamesPatchPtrOutput) } +func (o CustomResourceDefinitionNamesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionNamesPatch] { + return pulumix.Output[CustomResourceDefinitionNamesPatch]{ + OutputState: o.OutputState, + } +} + // categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. func (o CustomResourceDefinitionNamesPatchOutput) Categories() pulumi.StringArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionNamesPatch) []string { return v.Categories }).(pulumi.StringArrayOutput) @@ -1556,6 +1779,12 @@ func (o CustomResourceDefinitionNamesPatchPtrOutput) ToCustomResourceDefinitionN return o } +func (o CustomResourceDefinitionNamesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionNamesPatch] { + return pulumix.Output[*CustomResourceDefinitionNamesPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionNamesPatchPtrOutput) Elem() CustomResourceDefinitionNamesPatchOutput { return o.ApplyT(func(v *CustomResourceDefinitionNamesPatch) CustomResourceDefinitionNamesPatch { if v != nil { @@ -1675,6 +1904,12 @@ func (i CustomResourceDefinitionPatchTypeArgs) ToCustomResourceDefinitionPatchTy return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionPatchTypeOutput) } +func (i CustomResourceDefinitionPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionPatchType] { + return pulumix.Output[CustomResourceDefinitionPatchType]{ + OutputState: i.ToCustomResourceDefinitionPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. Deprecated in v1.16, planned for removal in v1.19. Use apiextensions.k8s.io/v1 CustomResourceDefinition instead. type CustomResourceDefinitionPatchTypeOutput struct{ *pulumi.OutputState } @@ -1690,6 +1925,12 @@ func (o CustomResourceDefinitionPatchTypeOutput) ToCustomResourceDefinitionPatch return o } +func (o CustomResourceDefinitionPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionPatchType] { + return pulumix.Output[CustomResourceDefinitionPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CustomResourceDefinitionPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1785,6 +2026,12 @@ func (i CustomResourceDefinitionSpecArgs) ToCustomResourceDefinitionSpecOutputWi return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionSpecOutput) } +func (i CustomResourceDefinitionSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpec] { + return pulumix.Output[CustomResourceDefinitionSpec]{ + OutputState: i.ToCustomResourceDefinitionSpecOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionSpec describes how a user wants their resource to appear type CustomResourceDefinitionSpecOutput struct{ *pulumi.OutputState } @@ -1800,6 +2047,12 @@ func (o CustomResourceDefinitionSpecOutput) ToCustomResourceDefinitionSpecOutput return o } +func (o CustomResourceDefinitionSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpec] { + return pulumix.Output[CustomResourceDefinitionSpec]{ + OutputState: o.OutputState, + } +} + // additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If present, this field configures columns for all versions. Top-level and per-version columns are mutually exclusive. If no top-level or per-version columns are specified, a single column displaying the age of the custom resource is used. func (o CustomResourceDefinitionSpecOutput) AdditionalPrinterColumns() CustomResourceColumnDefinitionArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionSpec) []CustomResourceColumnDefinition { @@ -1923,6 +2176,12 @@ func (i CustomResourceDefinitionSpecPatchArgs) ToCustomResourceDefinitionSpecPat return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionSpecPatchOutput) } +func (i CustomResourceDefinitionSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpecPatch] { + return pulumix.Output[CustomResourceDefinitionSpecPatch]{ + OutputState: i.ToCustomResourceDefinitionSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionSpecPatchArgs) ToCustomResourceDefinitionSpecPatchPtrOutput() CustomResourceDefinitionSpecPatchPtrOutput { return i.ToCustomResourceDefinitionSpecPatchPtrOutputWithContext(context.Background()) } @@ -1964,6 +2223,12 @@ func (i *customResourceDefinitionSpecPatchPtrType) ToCustomResourceDefinitionSpe return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionSpecPatchPtrOutput) } +func (i *customResourceDefinitionSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionSpecPatch] { + return pulumix.Output[*CustomResourceDefinitionSpecPatch]{ + OutputState: i.ToCustomResourceDefinitionSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionSpec describes how a user wants their resource to appear type CustomResourceDefinitionSpecPatchOutput struct{ *pulumi.OutputState } @@ -1989,6 +2254,12 @@ func (o CustomResourceDefinitionSpecPatchOutput) ToCustomResourceDefinitionSpecP }).(CustomResourceDefinitionSpecPatchPtrOutput) } +func (o CustomResourceDefinitionSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionSpecPatch] { + return pulumix.Output[CustomResourceDefinitionSpecPatch]{ + OutputState: o.OutputState, + } +} + // additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If present, this field configures columns for all versions. Top-level and per-version columns are mutually exclusive. If no top-level or per-version columns are specified, a single column displaying the age of the custom resource is used. func (o CustomResourceDefinitionSpecPatchOutput) AdditionalPrinterColumns() CustomResourceColumnDefinitionPatchArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionSpecPatch) []CustomResourceColumnDefinitionPatch { @@ -2055,6 +2326,12 @@ func (o CustomResourceDefinitionSpecPatchPtrOutput) ToCustomResourceDefinitionSp return o } +func (o CustomResourceDefinitionSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionSpecPatch] { + return pulumix.Output[*CustomResourceDefinitionSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionSpecPatchPtrOutput) Elem() CustomResourceDefinitionSpecPatchOutput { return o.ApplyT(func(v *CustomResourceDefinitionSpecPatch) CustomResourceDefinitionSpecPatch { if v != nil { @@ -2208,6 +2485,12 @@ func (i CustomResourceDefinitionStatusArgs) ToCustomResourceDefinitionStatusOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusOutput) } +func (i CustomResourceDefinitionStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatus] { + return pulumix.Output[CustomResourceDefinitionStatus]{ + OutputState: i.ToCustomResourceDefinitionStatusOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionStatusArgs) ToCustomResourceDefinitionStatusPtrOutput() CustomResourceDefinitionStatusPtrOutput { return i.ToCustomResourceDefinitionStatusPtrOutputWithContext(context.Background()) } @@ -2249,6 +2532,12 @@ func (i *customResourceDefinitionStatusPtrType) ToCustomResourceDefinitionStatus return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusPtrOutput) } +func (i *customResourceDefinitionStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatus] { + return pulumix.Output[*CustomResourceDefinitionStatus]{ + OutputState: i.ToCustomResourceDefinitionStatusPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition type CustomResourceDefinitionStatusOutput struct{ *pulumi.OutputState } @@ -2274,6 +2563,12 @@ func (o CustomResourceDefinitionStatusOutput) ToCustomResourceDefinitionStatusPt }).(CustomResourceDefinitionStatusPtrOutput) } +func (o CustomResourceDefinitionStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatus] { + return pulumix.Output[CustomResourceDefinitionStatus]{ + OutputState: o.OutputState, + } +} + // acceptedNames are the names that are actually being used to serve discovery. They may be different than the names in spec. func (o CustomResourceDefinitionStatusOutput) AcceptedNames() CustomResourceDefinitionNamesOutput { return o.ApplyT(func(v CustomResourceDefinitionStatus) CustomResourceDefinitionNames { return v.AcceptedNames }).(CustomResourceDefinitionNamesOutput) @@ -2303,6 +2598,12 @@ func (o CustomResourceDefinitionStatusPtrOutput) ToCustomResourceDefinitionStatu return o } +func (o CustomResourceDefinitionStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatus] { + return pulumix.Output[*CustomResourceDefinitionStatus]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionStatusPtrOutput) Elem() CustomResourceDefinitionStatusOutput { return o.ApplyT(func(v *CustomResourceDefinitionStatus) CustomResourceDefinitionStatus { if v != nil { @@ -2386,6 +2687,12 @@ func (i CustomResourceDefinitionStatusPatchArgs) ToCustomResourceDefinitionStatu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusPatchOutput) } +func (i CustomResourceDefinitionStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatusPatch] { + return pulumix.Output[CustomResourceDefinitionStatusPatch]{ + OutputState: i.ToCustomResourceDefinitionStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceDefinitionStatusPatchArgs) ToCustomResourceDefinitionStatusPatchPtrOutput() CustomResourceDefinitionStatusPatchPtrOutput { return i.ToCustomResourceDefinitionStatusPatchPtrOutputWithContext(context.Background()) } @@ -2427,6 +2734,12 @@ func (i *customResourceDefinitionStatusPatchPtrType) ToCustomResourceDefinitionS return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionStatusPatchPtrOutput) } +func (i *customResourceDefinitionStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatusPatch] { + return pulumix.Output[*CustomResourceDefinitionStatusPatch]{ + OutputState: i.ToCustomResourceDefinitionStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition type CustomResourceDefinitionStatusPatchOutput struct{ *pulumi.OutputState } @@ -2452,6 +2765,12 @@ func (o CustomResourceDefinitionStatusPatchOutput) ToCustomResourceDefinitionSta }).(CustomResourceDefinitionStatusPatchPtrOutput) } +func (o CustomResourceDefinitionStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionStatusPatch] { + return pulumix.Output[CustomResourceDefinitionStatusPatch]{ + OutputState: o.OutputState, + } +} + // acceptedNames are the names that are actually being used to serve discovery. They may be different than the names in spec. func (o CustomResourceDefinitionStatusPatchOutput) AcceptedNames() CustomResourceDefinitionNamesPatchPtrOutput { return o.ApplyT(func(v CustomResourceDefinitionStatusPatch) *CustomResourceDefinitionNamesPatch { @@ -2485,6 +2804,12 @@ func (o CustomResourceDefinitionStatusPatchPtrOutput) ToCustomResourceDefinition return o } +func (o CustomResourceDefinitionStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceDefinitionStatusPatch] { + return pulumix.Output[*CustomResourceDefinitionStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionStatusPatchPtrOutput) Elem() CustomResourceDefinitionStatusPatchOutput { return o.ApplyT(func(v *CustomResourceDefinitionStatusPatch) CustomResourceDefinitionStatusPatch { if v != nil { @@ -2588,6 +2913,12 @@ func (i CustomResourceDefinitionVersionArgs) ToCustomResourceDefinitionVersionOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionOutput) } +func (i CustomResourceDefinitionVersionArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersion] { + return pulumix.Output[CustomResourceDefinitionVersion]{ + OutputState: i.ToCustomResourceDefinitionVersionOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersionArrayInput is an input type that accepts CustomResourceDefinitionVersionArray and CustomResourceDefinitionVersionArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionVersionArrayInput` via: // @@ -2613,6 +2944,12 @@ func (i CustomResourceDefinitionVersionArray) ToCustomResourceDefinitionVersionA return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionArrayOutput) } +func (i CustomResourceDefinitionVersionArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersion] { + return pulumix.Output[[]CustomResourceDefinitionVersion]{ + OutputState: i.ToCustomResourceDefinitionVersionArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersion describes a version for CRD. type CustomResourceDefinitionVersionOutput struct{ *pulumi.OutputState } @@ -2628,6 +2965,12 @@ func (o CustomResourceDefinitionVersionOutput) ToCustomResourceDefinitionVersion return o } +func (o CustomResourceDefinitionVersionOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersion] { + return pulumix.Output[CustomResourceDefinitionVersion]{ + OutputState: o.OutputState, + } +} + // additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. Top-level and per-version columns are mutually exclusive. Per-version columns must not all be set to identical values (top-level columns should be used instead). If no top-level or per-version columns are specified, a single column displaying the age of the custom resource is used. func (o CustomResourceDefinitionVersionOutput) AdditionalPrinterColumns() CustomResourceColumnDefinitionArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionVersion) []CustomResourceColumnDefinition { @@ -2684,6 +3027,12 @@ func (o CustomResourceDefinitionVersionArrayOutput) ToCustomResourceDefinitionVe return o } +func (o CustomResourceDefinitionVersionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersion] { + return pulumix.Output[[]CustomResourceDefinitionVersion]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionVersionArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionVersionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionVersion { return vs[0].([]CustomResourceDefinitionVersion)[vs[1].(int)] @@ -2753,6 +3102,12 @@ func (i CustomResourceDefinitionVersionPatchArgs) ToCustomResourceDefinitionVers return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionPatchOutput) } +func (i CustomResourceDefinitionVersionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersionPatch] { + return pulumix.Output[CustomResourceDefinitionVersionPatch]{ + OutputState: i.ToCustomResourceDefinitionVersionPatchOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersionPatchArrayInput is an input type that accepts CustomResourceDefinitionVersionPatchArray and CustomResourceDefinitionVersionPatchArrayOutput values. // You can construct a concrete instance of `CustomResourceDefinitionVersionPatchArrayInput` via: // @@ -2778,6 +3133,12 @@ func (i CustomResourceDefinitionVersionPatchArray) ToCustomResourceDefinitionVer return pulumi.ToOutputWithContext(ctx, i).(CustomResourceDefinitionVersionPatchArrayOutput) } +func (i CustomResourceDefinitionVersionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersionPatch] { + return pulumix.Output[[]CustomResourceDefinitionVersionPatch]{ + OutputState: i.ToCustomResourceDefinitionVersionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CustomResourceDefinitionVersion describes a version for CRD. type CustomResourceDefinitionVersionPatchOutput struct{ *pulumi.OutputState } @@ -2793,6 +3154,12 @@ func (o CustomResourceDefinitionVersionPatchOutput) ToCustomResourceDefinitionVe return o } +func (o CustomResourceDefinitionVersionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceDefinitionVersionPatch] { + return pulumix.Output[CustomResourceDefinitionVersionPatch]{ + OutputState: o.OutputState, + } +} + // additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. Top-level and per-version columns are mutually exclusive. Per-version columns must not all be set to identical values (top-level columns should be used instead). If no top-level or per-version columns are specified, a single column displaying the age of the custom resource is used. func (o CustomResourceDefinitionVersionPatchOutput) AdditionalPrinterColumns() CustomResourceColumnDefinitionPatchArrayOutput { return o.ApplyT(func(v CustomResourceDefinitionVersionPatch) []CustomResourceColumnDefinitionPatch { @@ -2849,6 +3216,12 @@ func (o CustomResourceDefinitionVersionPatchArrayOutput) ToCustomResourceDefinit return o } +func (o CustomResourceDefinitionVersionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CustomResourceDefinitionVersionPatch] { + return pulumix.Output[[]CustomResourceDefinitionVersionPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceDefinitionVersionPatchArrayOutput) Index(i pulumi.IntInput) CustomResourceDefinitionVersionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomResourceDefinitionVersionPatch { return vs[0].([]CustomResourceDefinitionVersionPatch)[vs[1].(int)] @@ -2898,6 +3271,12 @@ func (i CustomResourceSubresourceScaleArgs) ToCustomResourceSubresourceScaleOutp return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScaleOutput) } +func (i CustomResourceSubresourceScaleArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScale] { + return pulumix.Output[CustomResourceSubresourceScale]{ + OutputState: i.ToCustomResourceSubresourceScaleOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourceScaleArgs) ToCustomResourceSubresourceScalePtrOutput() CustomResourceSubresourceScalePtrOutput { return i.ToCustomResourceSubresourceScalePtrOutputWithContext(context.Background()) } @@ -2939,6 +3318,12 @@ func (i *customResourceSubresourceScalePtrType) ToCustomResourceSubresourceScale return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScalePtrOutput) } +func (i *customResourceSubresourceScalePtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScale] { + return pulumix.Output[*CustomResourceSubresourceScale]{ + OutputState: i.ToCustomResourceSubresourceScalePtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources. type CustomResourceSubresourceScaleOutput struct{ *pulumi.OutputState } @@ -2964,6 +3349,12 @@ func (o CustomResourceSubresourceScaleOutput) ToCustomResourceSubresourceScalePt }).(CustomResourceSubresourceScalePtrOutput) } +func (o CustomResourceSubresourceScaleOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScale] { + return pulumix.Output[CustomResourceSubresourceScale]{ + OutputState: o.OutputState, + } +} + // labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. func (o CustomResourceSubresourceScaleOutput) LabelSelectorPath() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceSubresourceScale) *string { return v.LabelSelectorPath }).(pulumi.StringPtrOutput) @@ -2993,6 +3384,12 @@ func (o CustomResourceSubresourceScalePtrOutput) ToCustomResourceSubresourceScal return o } +func (o CustomResourceSubresourceScalePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScale] { + return pulumix.Output[*CustomResourceSubresourceScale]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourceScalePtrOutput) Elem() CustomResourceSubresourceScaleOutput { return o.ApplyT(func(v *CustomResourceSubresourceScale) CustomResourceSubresourceScale { if v != nil { @@ -3076,6 +3473,12 @@ func (i CustomResourceSubresourceScalePatchArgs) ToCustomResourceSubresourceScal return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScalePatchOutput) } +func (i CustomResourceSubresourceScalePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScalePatch] { + return pulumix.Output[CustomResourceSubresourceScalePatch]{ + OutputState: i.ToCustomResourceSubresourceScalePatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourceScalePatchArgs) ToCustomResourceSubresourceScalePatchPtrOutput() CustomResourceSubresourceScalePatchPtrOutput { return i.ToCustomResourceSubresourceScalePatchPtrOutputWithContext(context.Background()) } @@ -3117,6 +3520,12 @@ func (i *customResourceSubresourceScalePatchPtrType) ToCustomResourceSubresource return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourceScalePatchPtrOutput) } +func (i *customResourceSubresourceScalePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScalePatch] { + return pulumix.Output[*CustomResourceSubresourceScalePatch]{ + OutputState: i.ToCustomResourceSubresourceScalePatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources. type CustomResourceSubresourceScalePatchOutput struct{ *pulumi.OutputState } @@ -3142,6 +3551,12 @@ func (o CustomResourceSubresourceScalePatchOutput) ToCustomResourceSubresourceSc }).(CustomResourceSubresourceScalePatchPtrOutput) } +func (o CustomResourceSubresourceScalePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourceScalePatch] { + return pulumix.Output[CustomResourceSubresourceScalePatch]{ + OutputState: o.OutputState, + } +} + // labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. func (o CustomResourceSubresourceScalePatchOutput) LabelSelectorPath() pulumi.StringPtrOutput { return o.ApplyT(func(v CustomResourceSubresourceScalePatch) *string { return v.LabelSelectorPath }).(pulumi.StringPtrOutput) @@ -3171,6 +3586,12 @@ func (o CustomResourceSubresourceScalePatchPtrOutput) ToCustomResourceSubresourc return o } +func (o CustomResourceSubresourceScalePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourceScalePatch] { + return pulumix.Output[*CustomResourceSubresourceScalePatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourceScalePatchPtrOutput) Elem() CustomResourceSubresourceScalePatchOutput { return o.ApplyT(func(v *CustomResourceSubresourceScalePatch) CustomResourceSubresourceScalePatch { if v != nil { @@ -3250,6 +3671,12 @@ func (i CustomResourceSubresourcesArgs) ToCustomResourceSubresourcesOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesOutput) } +func (i CustomResourceSubresourcesArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresources] { + return pulumix.Output[CustomResourceSubresources]{ + OutputState: i.ToCustomResourceSubresourcesOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourcesArgs) ToCustomResourceSubresourcesPtrOutput() CustomResourceSubresourcesPtrOutput { return i.ToCustomResourceSubresourcesPtrOutputWithContext(context.Background()) } @@ -3291,6 +3718,12 @@ func (i *customResourceSubresourcesPtrType) ToCustomResourceSubresourcesPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesPtrOutput) } +func (i *customResourceSubresourcesPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresources] { + return pulumix.Output[*CustomResourceSubresources]{ + OutputState: i.ToCustomResourceSubresourcesPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresources defines the status and scale subresources for CustomResources. type CustomResourceSubresourcesOutput struct{ *pulumi.OutputState } @@ -3316,6 +3749,12 @@ func (o CustomResourceSubresourcesOutput) ToCustomResourceSubresourcesPtrOutputW }).(CustomResourceSubresourcesPtrOutput) } +func (o CustomResourceSubresourcesOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresources] { + return pulumix.Output[CustomResourceSubresources]{ + OutputState: o.OutputState, + } +} + // scale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object. func (o CustomResourceSubresourcesOutput) Scale() CustomResourceSubresourceScalePtrOutput { return o.ApplyT(func(v CustomResourceSubresources) *CustomResourceSubresourceScale { return v.Scale }).(CustomResourceSubresourceScalePtrOutput) @@ -3340,6 +3779,12 @@ func (o CustomResourceSubresourcesPtrOutput) ToCustomResourceSubresourcesPtrOutp return o } +func (o CustomResourceSubresourcesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresources] { + return pulumix.Output[*CustomResourceSubresources]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourcesPtrOutput) Elem() CustomResourceSubresourcesOutput { return o.ApplyT(func(v *CustomResourceSubresources) CustomResourceSubresources { if v != nil { @@ -3409,6 +3854,12 @@ func (i CustomResourceSubresourcesPatchArgs) ToCustomResourceSubresourcesPatchOu return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesPatchOutput) } +func (i CustomResourceSubresourcesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourcesPatch] { + return pulumix.Output[CustomResourceSubresourcesPatch]{ + OutputState: i.ToCustomResourceSubresourcesPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceSubresourcesPatchArgs) ToCustomResourceSubresourcesPatchPtrOutput() CustomResourceSubresourcesPatchPtrOutput { return i.ToCustomResourceSubresourcesPatchPtrOutputWithContext(context.Background()) } @@ -3450,6 +3901,12 @@ func (i *customResourceSubresourcesPatchPtrType) ToCustomResourceSubresourcesPat return pulumi.ToOutputWithContext(ctx, i).(CustomResourceSubresourcesPatchPtrOutput) } +func (i *customResourceSubresourcesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourcesPatch] { + return pulumix.Output[*CustomResourceSubresourcesPatch]{ + OutputState: i.ToCustomResourceSubresourcesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceSubresources defines the status and scale subresources for CustomResources. type CustomResourceSubresourcesPatchOutput struct{ *pulumi.OutputState } @@ -3475,6 +3932,12 @@ func (o CustomResourceSubresourcesPatchOutput) ToCustomResourceSubresourcesPatch }).(CustomResourceSubresourcesPatchPtrOutput) } +func (o CustomResourceSubresourcesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceSubresourcesPatch] { + return pulumix.Output[CustomResourceSubresourcesPatch]{ + OutputState: o.OutputState, + } +} + // scale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object. func (o CustomResourceSubresourcesPatchOutput) Scale() CustomResourceSubresourceScalePatchPtrOutput { return o.ApplyT(func(v CustomResourceSubresourcesPatch) *CustomResourceSubresourceScalePatch { return v.Scale }).(CustomResourceSubresourceScalePatchPtrOutput) @@ -3499,6 +3962,12 @@ func (o CustomResourceSubresourcesPatchPtrOutput) ToCustomResourceSubresourcesPa return o } +func (o CustomResourceSubresourcesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceSubresourcesPatch] { + return pulumix.Output[*CustomResourceSubresourcesPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceSubresourcesPatchPtrOutput) Elem() CustomResourceSubresourcesPatchOutput { return o.ApplyT(func(v *CustomResourceSubresourcesPatch) CustomResourceSubresourcesPatch { if v != nil { @@ -3564,6 +4033,12 @@ func (i CustomResourceValidationArgs) ToCustomResourceValidationOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationOutput) } +func (i CustomResourceValidationArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidation] { + return pulumix.Output[CustomResourceValidation]{ + OutputState: i.ToCustomResourceValidationOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceValidationArgs) ToCustomResourceValidationPtrOutput() CustomResourceValidationPtrOutput { return i.ToCustomResourceValidationPtrOutputWithContext(context.Background()) } @@ -3605,6 +4080,12 @@ func (i *customResourceValidationPtrType) ToCustomResourceValidationPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationPtrOutput) } +func (i *customResourceValidationPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidation] { + return pulumix.Output[*CustomResourceValidation]{ + OutputState: i.ToCustomResourceValidationPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceValidation is a list of validation methods for CustomResources. type CustomResourceValidationOutput struct{ *pulumi.OutputState } @@ -3630,6 +4111,12 @@ func (o CustomResourceValidationOutput) ToCustomResourceValidationPtrOutputWithC }).(CustomResourceValidationPtrOutput) } +func (o CustomResourceValidationOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidation] { + return pulumix.Output[CustomResourceValidation]{ + OutputState: o.OutputState, + } +} + // openAPIV3Schema is the OpenAPI v3 schema to use for validation and pruning. func (o CustomResourceValidationOutput) OpenAPIV3Schema() JSONSchemaPropsPtrOutput { return o.ApplyT(func(v CustomResourceValidation) *JSONSchemaProps { return v.OpenAPIV3Schema }).(JSONSchemaPropsPtrOutput) @@ -3649,6 +4136,12 @@ func (o CustomResourceValidationPtrOutput) ToCustomResourceValidationPtrOutputWi return o } +func (o CustomResourceValidationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidation] { + return pulumix.Output[*CustomResourceValidation]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceValidationPtrOutput) Elem() CustomResourceValidationOutput { return o.ApplyT(func(v *CustomResourceValidation) CustomResourceValidation { if v != nil { @@ -3704,6 +4197,12 @@ func (i CustomResourceValidationPatchArgs) ToCustomResourceValidationPatchOutput return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationPatchOutput) } +func (i CustomResourceValidationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidationPatch] { + return pulumix.Output[CustomResourceValidationPatch]{ + OutputState: i.ToCustomResourceValidationPatchOutputWithContext(ctx).OutputState, + } +} + func (i CustomResourceValidationPatchArgs) ToCustomResourceValidationPatchPtrOutput() CustomResourceValidationPatchPtrOutput { return i.ToCustomResourceValidationPatchPtrOutputWithContext(context.Background()) } @@ -3745,6 +4244,12 @@ func (i *customResourceValidationPatchPtrType) ToCustomResourceValidationPatchPt return pulumi.ToOutputWithContext(ctx, i).(CustomResourceValidationPatchPtrOutput) } +func (i *customResourceValidationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidationPatch] { + return pulumix.Output[*CustomResourceValidationPatch]{ + OutputState: i.ToCustomResourceValidationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CustomResourceValidation is a list of validation methods for CustomResources. type CustomResourceValidationPatchOutput struct{ *pulumi.OutputState } @@ -3770,6 +4275,12 @@ func (o CustomResourceValidationPatchOutput) ToCustomResourceValidationPatchPtrO }).(CustomResourceValidationPatchPtrOutput) } +func (o CustomResourceValidationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CustomResourceValidationPatch] { + return pulumix.Output[CustomResourceValidationPatch]{ + OutputState: o.OutputState, + } +} + // openAPIV3Schema is the OpenAPI v3 schema to use for validation and pruning. func (o CustomResourceValidationPatchOutput) OpenAPIV3Schema() JSONSchemaPropsPatchPtrOutput { return o.ApplyT(func(v CustomResourceValidationPatch) *JSONSchemaPropsPatch { return v.OpenAPIV3Schema }).(JSONSchemaPropsPatchPtrOutput) @@ -3789,6 +4300,12 @@ func (o CustomResourceValidationPatchPtrOutput) ToCustomResourceValidationPatchP return o } +func (o CustomResourceValidationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CustomResourceValidationPatch] { + return pulumix.Output[*CustomResourceValidationPatch]{ + OutputState: o.OutputState, + } +} + func (o CustomResourceValidationPatchPtrOutput) Elem() CustomResourceValidationPatchOutput { return o.ApplyT(func(v *CustomResourceValidationPatch) CustomResourceValidationPatch { if v != nil { @@ -3844,6 +4361,12 @@ func (i ExternalDocumentationArgs) ToExternalDocumentationOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationOutput) } +func (i ExternalDocumentationArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentation] { + return pulumix.Output[ExternalDocumentation]{ + OutputState: i.ToExternalDocumentationOutputWithContext(ctx).OutputState, + } +} + func (i ExternalDocumentationArgs) ToExternalDocumentationPtrOutput() ExternalDocumentationPtrOutput { return i.ToExternalDocumentationPtrOutputWithContext(context.Background()) } @@ -3885,6 +4408,12 @@ func (i *externalDocumentationPtrType) ToExternalDocumentationPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationPtrOutput) } +func (i *externalDocumentationPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentation] { + return pulumix.Output[*ExternalDocumentation]{ + OutputState: i.ToExternalDocumentationPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalDocumentation allows referencing an external resource for extended documentation. type ExternalDocumentationOutput struct{ *pulumi.OutputState } @@ -3910,6 +4439,12 @@ func (o ExternalDocumentationOutput) ToExternalDocumentationPtrOutputWithContext }).(ExternalDocumentationPtrOutput) } +func (o ExternalDocumentationOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentation] { + return pulumix.Output[ExternalDocumentation]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalDocumentation) *string { return v.Description }).(pulumi.StringPtrOutput) } @@ -3932,6 +4467,12 @@ func (o ExternalDocumentationPtrOutput) ToExternalDocumentationPtrOutputWithCont return o } +func (o ExternalDocumentationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentation] { + return pulumix.Output[*ExternalDocumentation]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationPtrOutput) Elem() ExternalDocumentationOutput { return o.ApplyT(func(v *ExternalDocumentation) ExternalDocumentation { if v != nil { @@ -3995,6 +4536,12 @@ func (i ExternalDocumentationPatchArgs) ToExternalDocumentationPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationPatchOutput) } +func (i ExternalDocumentationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentationPatch] { + return pulumix.Output[ExternalDocumentationPatch]{ + OutputState: i.ToExternalDocumentationPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalDocumentationPatchArgs) ToExternalDocumentationPatchPtrOutput() ExternalDocumentationPatchPtrOutput { return i.ToExternalDocumentationPatchPtrOutputWithContext(context.Background()) } @@ -4036,6 +4583,12 @@ func (i *externalDocumentationPatchPtrType) ToExternalDocumentationPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ExternalDocumentationPatchPtrOutput) } +func (i *externalDocumentationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentationPatch] { + return pulumix.Output[*ExternalDocumentationPatch]{ + OutputState: i.ToExternalDocumentationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalDocumentation allows referencing an external resource for extended documentation. type ExternalDocumentationPatchOutput struct{ *pulumi.OutputState } @@ -4061,6 +4614,12 @@ func (o ExternalDocumentationPatchOutput) ToExternalDocumentationPatchPtrOutputW }).(ExternalDocumentationPatchPtrOutput) } +func (o ExternalDocumentationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalDocumentationPatch] { + return pulumix.Output[ExternalDocumentationPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationPatchOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalDocumentationPatch) *string { return v.Description }).(pulumi.StringPtrOutput) } @@ -4083,6 +4642,12 @@ func (o ExternalDocumentationPatchPtrOutput) ToExternalDocumentationPatchPtrOutp return o } +func (o ExternalDocumentationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalDocumentationPatch] { + return pulumix.Output[*ExternalDocumentationPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalDocumentationPatchPtrOutput) Elem() ExternalDocumentationPatchOutput { return o.ApplyT(func(v *ExternalDocumentationPatch) ExternalDocumentationPatch { if v != nil { @@ -4310,6 +4875,12 @@ func (i JSONSchemaPropsArgs) ToJSONSchemaPropsOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsOutput) } +func (i JSONSchemaPropsArgs) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaProps] { + return pulumix.Output[JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsOutputWithContext(ctx).OutputState, + } +} + func (i JSONSchemaPropsArgs) ToJSONSchemaPropsPtrOutput() JSONSchemaPropsPtrOutput { return i.ToJSONSchemaPropsPtrOutputWithContext(context.Background()) } @@ -4351,6 +4922,12 @@ func (i *jsonschemaPropsPtrType) ToJSONSchemaPropsPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPtrOutput) } +func (i *jsonschemaPropsPtrType) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaProps] { + return pulumix.Output[*JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsPtrOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaPropsArrayInput is an input type that accepts JSONSchemaPropsArray and JSONSchemaPropsArrayOutput values. // You can construct a concrete instance of `JSONSchemaPropsArrayInput` via: // @@ -4376,6 +4953,12 @@ func (i JSONSchemaPropsArray) ToJSONSchemaPropsArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsArrayOutput) } +func (i JSONSchemaPropsArray) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaProps] { + return pulumix.Output[[]JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsArrayOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaPropsMapInput is an input type that accepts JSONSchemaPropsMap and JSONSchemaPropsMapOutput values. // You can construct a concrete instance of `JSONSchemaPropsMapInput` via: // @@ -4401,6 +4984,12 @@ func (i JSONSchemaPropsMap) ToJSONSchemaPropsMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsMapOutput) } +func (i JSONSchemaPropsMap) ToOutput(ctx context.Context) pulumix.Output[map[string]JSONSchemaProps] { + return pulumix.Output[map[string]JSONSchemaProps]{ + OutputState: i.ToJSONSchemaPropsMapOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). type JSONSchemaPropsOutput struct{ *pulumi.OutputState } @@ -4426,6 +5015,12 @@ func (o JSONSchemaPropsOutput) ToJSONSchemaPropsPtrOutputWithContext(ctx context }).(JSONSchemaPropsPtrOutput) } +func (o JSONSchemaPropsOutput) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaProps] { + return pulumix.Output[JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsOutput) Ref() pulumi.StringPtrOutput { return o.ApplyT(func(v JSONSchemaProps) *string { return v.Ref }).(pulumi.StringPtrOutput) } @@ -4654,6 +5249,12 @@ func (o JSONSchemaPropsPtrOutput) ToJSONSchemaPropsPtrOutputWithContext(ctx cont return o } +func (o JSONSchemaPropsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaProps] { + return pulumix.Output[*JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPtrOutput) Elem() JSONSchemaPropsOutput { return o.ApplyT(func(v *JSONSchemaProps) JSONSchemaProps { if v != nil { @@ -5107,6 +5708,12 @@ func (o JSONSchemaPropsArrayOutput) ToJSONSchemaPropsArrayOutputWithContext(ctx return o } +func (o JSONSchemaPropsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaProps] { + return pulumix.Output[[]JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsArrayOutput) Index(i pulumi.IntInput) JSONSchemaPropsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JSONSchemaProps { return vs[0].([]JSONSchemaProps)[vs[1].(int)] @@ -5127,6 +5734,12 @@ func (o JSONSchemaPropsMapOutput) ToJSONSchemaPropsMapOutputWithContext(ctx cont return o } +func (o JSONSchemaPropsMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]JSONSchemaProps] { + return pulumix.Output[map[string]JSONSchemaProps]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsMapOutput) MapIndex(k pulumi.StringInput) JSONSchemaPropsOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) JSONSchemaProps { return vs[0].(map[string]JSONSchemaProps)[vs[1].(string)] @@ -5332,6 +5945,12 @@ func (i JSONSchemaPropsPatchArgs) ToJSONSchemaPropsPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPatchOutput) } +func (i JSONSchemaPropsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaPropsPatch] { + return pulumix.Output[JSONSchemaPropsPatch]{ + OutputState: i.ToJSONSchemaPropsPatchOutputWithContext(ctx).OutputState, + } +} + func (i JSONSchemaPropsPatchArgs) ToJSONSchemaPropsPatchPtrOutput() JSONSchemaPropsPatchPtrOutput { return i.ToJSONSchemaPropsPatchPtrOutputWithContext(context.Background()) } @@ -5373,6 +5992,12 @@ func (i *jsonschemaPropsPatchPtrType) ToJSONSchemaPropsPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPatchPtrOutput) } +func (i *jsonschemaPropsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaPropsPatch] { + return pulumix.Output[*JSONSchemaPropsPatch]{ + OutputState: i.ToJSONSchemaPropsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaPropsPatchArrayInput is an input type that accepts JSONSchemaPropsPatchArray and JSONSchemaPropsPatchArrayOutput values. // You can construct a concrete instance of `JSONSchemaPropsPatchArrayInput` via: // @@ -5398,6 +6023,12 @@ func (i JSONSchemaPropsPatchArray) ToJSONSchemaPropsPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(JSONSchemaPropsPatchArrayOutput) } +func (i JSONSchemaPropsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaPropsPatch] { + return pulumix.Output[[]JSONSchemaPropsPatch]{ + OutputState: i.ToJSONSchemaPropsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). type JSONSchemaPropsPatchOutput struct{ *pulumi.OutputState } @@ -5423,6 +6054,12 @@ func (o JSONSchemaPropsPatchOutput) ToJSONSchemaPropsPatchPtrOutputWithContext(c }).(JSONSchemaPropsPatchPtrOutput) } +func (o JSONSchemaPropsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JSONSchemaPropsPatch] { + return pulumix.Output[JSONSchemaPropsPatch]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPatchOutput) Ref() pulumi.StringPtrOutput { return o.ApplyT(func(v JSONSchemaPropsPatch) *string { return v.Ref }).(pulumi.StringPtrOutput) } @@ -5651,6 +6288,12 @@ func (o JSONSchemaPropsPatchPtrOutput) ToJSONSchemaPropsPatchPtrOutputWithContex return o } +func (o JSONSchemaPropsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JSONSchemaPropsPatch] { + return pulumix.Output[*JSONSchemaPropsPatch]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPatchPtrOutput) Elem() JSONSchemaPropsPatchOutput { return o.ApplyT(func(v *JSONSchemaPropsPatch) JSONSchemaPropsPatch { if v != nil { @@ -6104,6 +6747,12 @@ func (o JSONSchemaPropsPatchArrayOutput) ToJSONSchemaPropsPatchArrayOutputWithCo return o } +func (o JSONSchemaPropsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JSONSchemaPropsPatch] { + return pulumix.Output[[]JSONSchemaPropsPatch]{ + OutputState: o.OutputState, + } +} + func (o JSONSchemaPropsPatchArrayOutput) Index(i pulumi.IntInput) JSONSchemaPropsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JSONSchemaPropsPatch { return vs[0].([]JSONSchemaPropsPatch)[vs[1].(int)] @@ -6157,6 +6806,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -6198,6 +6853,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -6223,6 +6884,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // name is the name of the service. Required func (o ServiceReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceReference) string { return v.Name }).(pulumi.StringOutput) @@ -6257,6 +6924,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -6354,6 +7027,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -6395,6 +7074,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -6420,6 +7105,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the service. Required func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -6454,6 +7145,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { @@ -6571,6 +7268,12 @@ func (i WebhookClientConfigArgs) ToWebhookClientConfigOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigOutput) } +func (i WebhookClientConfigArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigArgs) ToWebhookClientConfigPtrOutput() WebhookClientConfigPtrOutput { return i.ToWebhookClientConfigPtrOutputWithContext(context.Background()) } @@ -6612,6 +7315,12 @@ func (i *webhookClientConfigPtrType) ToWebhookClientConfigPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPtrOutput) } +func (i *webhookClientConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfig] { + return pulumix.Output[*WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook. type WebhookClientConfigOutput struct{ *pulumi.OutputState } @@ -6637,6 +7346,12 @@ func (o WebhookClientConfigOutput) ToWebhookClientConfigPtrOutputWithContext(ctx }).(WebhookClientConfigPtrOutput) } +func (o WebhookClientConfigOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + // caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfig) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -6678,6 +7393,12 @@ func (o WebhookClientConfigPtrOutput) ToWebhookClientConfigPtrOutputWithContext( return o } +func (o WebhookClientConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfig] { + return pulumix.Output[*WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPtrOutput) Elem() WebhookClientConfigOutput { return o.ApplyT(func(v *WebhookClientConfig) WebhookClientConfig { if v != nil { @@ -6797,6 +7518,12 @@ func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchOutput) } +func (i WebhookClientConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchPtrOutput() WebhookClientConfigPatchPtrOutput { return i.ToWebhookClientConfigPatchPtrOutputWithContext(context.Background()) } @@ -6838,6 +7565,12 @@ func (i *webhookClientConfigPatchPtrType) ToWebhookClientConfigPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchPtrOutput) } +func (i *webhookClientConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook. type WebhookClientConfigPatchOutput struct{ *pulumi.OutputState } @@ -6863,6 +7596,12 @@ func (o WebhookClientConfigPatchOutput) ToWebhookClientConfigPatchPtrOutputWithC }).(WebhookClientConfigPatchPtrOutput) } +func (o WebhookClientConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + // caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfigPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -6904,6 +7643,12 @@ func (o WebhookClientConfigPatchPtrOutput) ToWebhookClientConfigPatchPtrOutputWi return o } +func (o WebhookClientConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPatchPtrOutput) Elem() WebhookClientConfigPatchOutput { return o.ApplyT(func(v *WebhookClientConfigPatch) WebhookClientConfigPatch { if v != nil { diff --git a/sdk/go/kubernetes/apiregistration/v1/apiservice.go b/sdk/go/kubernetes/apiregistration/v1/apiservice.go index 146b07ef9e..f169b75ef1 100644 --- a/sdk/go/kubernetes/apiregistration/v1/apiservice.go +++ b/sdk/go/kubernetes/apiregistration/v1/apiservice.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // APIService represents a server for a particular GroupVersion. Name must be "version.group". @@ -127,6 +128,12 @@ func (i *APIService) ToAPIServiceOutputWithContext(ctx context.Context) APIServi return pulumi.ToOutputWithContext(ctx, i).(APIServiceOutput) } +func (i *APIService) ToOutput(ctx context.Context) pulumix.Output[*APIService] { + return pulumix.Output[*APIService]{ + OutputState: i.ToAPIServiceOutputWithContext(ctx).OutputState, + } +} + // APIServiceArrayInput is an input type that accepts APIServiceArray and APIServiceArrayOutput values. // You can construct a concrete instance of `APIServiceArrayInput` via: // @@ -152,6 +159,12 @@ func (i APIServiceArray) ToAPIServiceArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(APIServiceArrayOutput) } +func (i APIServiceArray) ToOutput(ctx context.Context) pulumix.Output[[]*APIService] { + return pulumix.Output[[]*APIService]{ + OutputState: i.ToAPIServiceArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceMapInput is an input type that accepts APIServiceMap and APIServiceMapOutput values. // You can construct a concrete instance of `APIServiceMapInput` via: // @@ -177,6 +190,12 @@ func (i APIServiceMap) ToAPIServiceMapOutputWithContext(ctx context.Context) API return pulumi.ToOutputWithContext(ctx, i).(APIServiceMapOutput) } +func (i APIServiceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIService] { + return pulumix.Output[map[string]*APIService]{ + OutputState: i.ToAPIServiceMapOutputWithContext(ctx).OutputState, + } +} + type APIServiceOutput struct{ *pulumi.OutputState } func (APIServiceOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o APIServiceOutput) ToAPIServiceOutputWithContext(ctx context.Context) API return o } +func (o APIServiceOutput) ToOutput(ctx context.Context) pulumix.Output[*APIService] { + return pulumix.Output[*APIService]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *APIService) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o APIServiceArrayOutput) ToAPIServiceArrayOutputWithContext(ctx context.Co return o } +func (o APIServiceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*APIService] { + return pulumix.Output[[]*APIService]{ + OutputState: o.OutputState, + } +} + func (o APIServiceArrayOutput) Index(i pulumi.IntInput) APIServiceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *APIService { return vs[0].([]*APIService)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o APIServiceMapOutput) ToAPIServiceMapOutputWithContext(ctx context.Contex return o } +func (o APIServiceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIService] { + return pulumix.Output[map[string]*APIService]{ + OutputState: o.OutputState, + } +} + func (o APIServiceMapOutput) MapIndex(k pulumi.StringInput) APIServiceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *APIService { return vs[0].(map[string]*APIService)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiregistration/v1/apiserviceList.go b/sdk/go/kubernetes/apiregistration/v1/apiserviceList.go index 55aaeb97da..91572fd820 100644 --- a/sdk/go/kubernetes/apiregistration/v1/apiserviceList.go +++ b/sdk/go/kubernetes/apiregistration/v1/apiserviceList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // APIServiceList is a list of APIService objects. @@ -123,6 +124,12 @@ func (i *APIServiceList) ToAPIServiceListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(APIServiceListOutput) } +func (i *APIServiceList) ToOutput(ctx context.Context) pulumix.Output[*APIServiceList] { + return pulumix.Output[*APIServiceList]{ + OutputState: i.ToAPIServiceListOutputWithContext(ctx).OutputState, + } +} + // APIServiceListArrayInput is an input type that accepts APIServiceListArray and APIServiceListArrayOutput values. // You can construct a concrete instance of `APIServiceListArrayInput` via: // @@ -148,6 +155,12 @@ func (i APIServiceListArray) ToAPIServiceListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(APIServiceListArrayOutput) } +func (i APIServiceListArray) ToOutput(ctx context.Context) pulumix.Output[[]*APIServiceList] { + return pulumix.Output[[]*APIServiceList]{ + OutputState: i.ToAPIServiceListArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceListMapInput is an input type that accepts APIServiceListMap and APIServiceListMapOutput values. // You can construct a concrete instance of `APIServiceListMapInput` via: // @@ -173,6 +186,12 @@ func (i APIServiceListMap) ToAPIServiceListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(APIServiceListMapOutput) } +func (i APIServiceListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServiceList] { + return pulumix.Output[map[string]*APIServiceList]{ + OutputState: i.ToAPIServiceListMapOutputWithContext(ctx).OutputState, + } +} + type APIServiceListOutput struct{ *pulumi.OutputState } func (APIServiceListOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o APIServiceListOutput) ToAPIServiceListOutputWithContext(ctx context.Cont return o } +func (o APIServiceListOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceList] { + return pulumix.Output[*APIServiceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *APIServiceList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -221,6 +246,12 @@ func (o APIServiceListArrayOutput) ToAPIServiceListArrayOutputWithContext(ctx co return o } +func (o APIServiceListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*APIServiceList] { + return pulumix.Output[[]*APIServiceList]{ + OutputState: o.OutputState, + } +} + func (o APIServiceListArrayOutput) Index(i pulumi.IntInput) APIServiceListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *APIServiceList { return vs[0].([]*APIServiceList)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o APIServiceListMapOutput) ToAPIServiceListMapOutputWithContext(ctx contex return o } +func (o APIServiceListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServiceList] { + return pulumix.Output[map[string]*APIServiceList]{ + OutputState: o.OutputState, + } +} + func (o APIServiceListMapOutput) MapIndex(k pulumi.StringInput) APIServiceListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *APIServiceList { return vs[0].(map[string]*APIServiceList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiregistration/v1/apiservicePatch.go b/sdk/go/kubernetes/apiregistration/v1/apiservicePatch.go index 5220d5776f..e7d0eaacfc 100644 --- a/sdk/go/kubernetes/apiregistration/v1/apiservicePatch.go +++ b/sdk/go/kubernetes/apiregistration/v1/apiservicePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *APIServicePatch) ToAPIServicePatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchOutput) } +func (i *APIServicePatch) ToOutput(ctx context.Context) pulumix.Output[*APIServicePatch] { + return pulumix.Output[*APIServicePatch]{ + OutputState: i.ToAPIServicePatchOutputWithContext(ctx).OutputState, + } +} + // APIServicePatchArrayInput is an input type that accepts APIServicePatchArray and APIServicePatchArrayOutput values. // You can construct a concrete instance of `APIServicePatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i APIServicePatchArray) ToAPIServicePatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchArrayOutput) } +func (i APIServicePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*APIServicePatch] { + return pulumix.Output[[]*APIServicePatch]{ + OutputState: i.ToAPIServicePatchArrayOutputWithContext(ctx).OutputState, + } +} + // APIServicePatchMapInput is an input type that accepts APIServicePatchMap and APIServicePatchMapOutput values. // You can construct a concrete instance of `APIServicePatchMapInput` via: // @@ -183,6 +196,12 @@ func (i APIServicePatchMap) ToAPIServicePatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchMapOutput) } +func (i APIServicePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServicePatch] { + return pulumix.Output[map[string]*APIServicePatch]{ + OutputState: i.ToAPIServicePatchMapOutputWithContext(ctx).OutputState, + } +} + type APIServicePatchOutput struct{ *pulumi.OutputState } func (APIServicePatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o APIServicePatchOutput) ToAPIServicePatchOutputWithContext(ctx context.Co return o } +func (o APIServicePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServicePatch] { + return pulumix.Output[*APIServicePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServicePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *APIServicePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o APIServicePatchArrayOutput) ToAPIServicePatchArrayOutputWithContext(ctx return o } +func (o APIServicePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*APIServicePatch] { + return pulumix.Output[[]*APIServicePatch]{ + OutputState: o.OutputState, + } +} + func (o APIServicePatchArrayOutput) Index(i pulumi.IntInput) APIServicePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *APIServicePatch { return vs[0].([]*APIServicePatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o APIServicePatchMapOutput) ToAPIServicePatchMapOutputWithContext(ctx cont return o } +func (o APIServicePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServicePatch] { + return pulumix.Output[map[string]*APIServicePatch]{ + OutputState: o.OutputState, + } +} + func (o APIServicePatchMapOutput) MapIndex(k pulumi.StringInput) APIServicePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *APIServicePatch { return vs[0].(map[string]*APIServicePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiregistration/v1/pulumiTypes.go b/sdk/go/kubernetes/apiregistration/v1/pulumiTypes.go index 59ede1837b..ff10bc2832 100644 --- a/sdk/go/kubernetes/apiregistration/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/apiregistration/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -65,6 +66,12 @@ func (i APIServiceTypeArgs) ToAPIServiceTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(APIServiceTypeOutput) } +func (i APIServiceTypeArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceType] { + return pulumix.Output[APIServiceType]{ + OutputState: i.ToAPIServiceTypeOutputWithContext(ctx).OutputState, + } +} + // APIServiceTypeArrayInput is an input type that accepts APIServiceTypeArray and APIServiceTypeArrayOutput values. // You can construct a concrete instance of `APIServiceTypeArrayInput` via: // @@ -90,6 +97,12 @@ func (i APIServiceTypeArray) ToAPIServiceTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(APIServiceTypeArrayOutput) } +func (i APIServiceTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceType] { + return pulumix.Output[[]APIServiceType]{ + OutputState: i.ToAPIServiceTypeArrayOutputWithContext(ctx).OutputState, + } +} + // APIService represents a server for a particular GroupVersion. Name must be "version.group". type APIServiceTypeOutput struct{ *pulumi.OutputState } @@ -105,6 +118,12 @@ func (o APIServiceTypeOutput) ToAPIServiceTypeOutputWithContext(ctx context.Cont return o } +func (o APIServiceTypeOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceType] { + return pulumix.Output[APIServiceType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -144,6 +163,12 @@ func (o APIServiceTypeArrayOutput) ToAPIServiceTypeArrayOutputWithContext(ctx co return o } +func (o APIServiceTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceType] { + return pulumix.Output[[]APIServiceType]{ + OutputState: o.OutputState, + } +} + func (o APIServiceTypeArrayOutput) Index(i pulumi.IntInput) APIServiceTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIServiceType { return vs[0].([]APIServiceType)[vs[1].(int)] @@ -201,6 +226,12 @@ func (i APIServiceConditionArgs) ToAPIServiceConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionOutput) } +func (i APIServiceConditionArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceCondition] { + return pulumix.Output[APIServiceCondition]{ + OutputState: i.ToAPIServiceConditionOutputWithContext(ctx).OutputState, + } +} + // APIServiceConditionArrayInput is an input type that accepts APIServiceConditionArray and APIServiceConditionArrayOutput values. // You can construct a concrete instance of `APIServiceConditionArrayInput` via: // @@ -226,6 +257,12 @@ func (i APIServiceConditionArray) ToAPIServiceConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionArrayOutput) } +func (i APIServiceConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceCondition] { + return pulumix.Output[[]APIServiceCondition]{ + OutputState: i.ToAPIServiceConditionArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceCondition describes the state of an APIService at a particular point type APIServiceConditionOutput struct{ *pulumi.OutputState } @@ -241,6 +278,12 @@ func (o APIServiceConditionOutput) ToAPIServiceConditionOutputWithContext(ctx co return o } +func (o APIServiceConditionOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceCondition] { + return pulumix.Output[APIServiceCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o APIServiceConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -280,6 +323,12 @@ func (o APIServiceConditionArrayOutput) ToAPIServiceConditionArrayOutputWithCont return o } +func (o APIServiceConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceCondition] { + return pulumix.Output[[]APIServiceCondition]{ + OutputState: o.OutputState, + } +} + func (o APIServiceConditionArrayOutput) Index(i pulumi.IntInput) APIServiceConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIServiceCondition { return vs[0].([]APIServiceCondition)[vs[1].(int)] @@ -337,6 +386,12 @@ func (i APIServiceConditionPatchArgs) ToAPIServiceConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionPatchOutput) } +func (i APIServiceConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceConditionPatch] { + return pulumix.Output[APIServiceConditionPatch]{ + OutputState: i.ToAPIServiceConditionPatchOutputWithContext(ctx).OutputState, + } +} + // APIServiceConditionPatchArrayInput is an input type that accepts APIServiceConditionPatchArray and APIServiceConditionPatchArrayOutput values. // You can construct a concrete instance of `APIServiceConditionPatchArrayInput` via: // @@ -362,6 +417,12 @@ func (i APIServiceConditionPatchArray) ToAPIServiceConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionPatchArrayOutput) } +func (i APIServiceConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceConditionPatch] { + return pulumix.Output[[]APIServiceConditionPatch]{ + OutputState: i.ToAPIServiceConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceCondition describes the state of an APIService at a particular point type APIServiceConditionPatchOutput struct{ *pulumi.OutputState } @@ -377,6 +438,12 @@ func (o APIServiceConditionPatchOutput) ToAPIServiceConditionPatchOutputWithCont return o } +func (o APIServiceConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceConditionPatch] { + return pulumix.Output[APIServiceConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o APIServiceConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -416,6 +483,12 @@ func (o APIServiceConditionPatchArrayOutput) ToAPIServiceConditionPatchArrayOutp return o } +func (o APIServiceConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceConditionPatch] { + return pulumix.Output[[]APIServiceConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o APIServiceConditionPatchArrayOutput) Index(i pulumi.IntInput) APIServiceConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIServiceConditionPatch { return vs[0].([]APIServiceConditionPatch)[vs[1].(int)] @@ -469,6 +542,12 @@ func (i APIServiceListTypeArgs) ToAPIServiceListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(APIServiceListTypeOutput) } +func (i APIServiceListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceListType] { + return pulumix.Output[APIServiceListType]{ + OutputState: i.ToAPIServiceListTypeOutputWithContext(ctx).OutputState, + } +} + // APIServiceList is a list of APIService objects. type APIServiceListTypeOutput struct{ *pulumi.OutputState } @@ -484,6 +563,12 @@ func (o APIServiceListTypeOutput) ToAPIServiceListTypeOutputWithContext(ctx cont return o } +func (o APIServiceListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceListType] { + return pulumix.Output[APIServiceListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -555,6 +640,12 @@ func (i APIServicePatchTypeArgs) ToAPIServicePatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchTypeOutput) } +func (i APIServicePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[APIServicePatchType] { + return pulumix.Output[APIServicePatchType]{ + OutputState: i.ToAPIServicePatchTypeOutputWithContext(ctx).OutputState, + } +} + // APIService represents a server for a particular GroupVersion. Name must be "version.group". type APIServicePatchTypeOutput struct{ *pulumi.OutputState } @@ -570,6 +661,12 @@ func (o APIServicePatchTypeOutput) ToAPIServicePatchTypeOutputWithContext(ctx co return o } +func (o APIServicePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[APIServicePatchType] { + return pulumix.Output[APIServicePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServicePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServicePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -654,6 +751,12 @@ func (i APIServiceSpecArgs) ToAPIServiceSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecOutput) } +func (i APIServiceSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpec] { + return pulumix.Output[APIServiceSpec]{ + OutputState: i.ToAPIServiceSpecOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceSpecArgs) ToAPIServiceSpecPtrOutput() APIServiceSpecPtrOutput { return i.ToAPIServiceSpecPtrOutputWithContext(context.Background()) } @@ -695,6 +798,12 @@ func (i *apiserviceSpecPtrType) ToAPIServiceSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecPtrOutput) } +func (i *apiserviceSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpec] { + return pulumix.Output[*APIServiceSpec]{ + OutputState: i.ToAPIServiceSpecPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. type APIServiceSpecOutput struct{ *pulumi.OutputState } @@ -720,6 +829,12 @@ func (o APIServiceSpecOutput) ToAPIServiceSpecPtrOutputWithContext(ctx context.C }).(APIServiceSpecPtrOutput) } +func (o APIServiceSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpec] { + return pulumix.Output[APIServiceSpec]{ + OutputState: o.OutputState, + } +} + // CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. func (o APIServiceSpecOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceSpec) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -769,6 +884,12 @@ func (o APIServiceSpecPtrOutput) ToAPIServiceSpecPtrOutputWithContext(ctx contex return o } +func (o APIServiceSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpec] { + return pulumix.Output[*APIServiceSpec]{ + OutputState: o.OutputState, + } +} + func (o APIServiceSpecPtrOutput) Elem() APIServiceSpecOutput { return o.ApplyT(func(v *APIServiceSpec) APIServiceSpec { if v != nil { @@ -908,6 +1029,12 @@ func (i APIServiceSpecPatchArgs) ToAPIServiceSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecPatchOutput) } +func (i APIServiceSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpecPatch] { + return pulumix.Output[APIServiceSpecPatch]{ + OutputState: i.ToAPIServiceSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceSpecPatchArgs) ToAPIServiceSpecPatchPtrOutput() APIServiceSpecPatchPtrOutput { return i.ToAPIServiceSpecPatchPtrOutputWithContext(context.Background()) } @@ -949,6 +1076,12 @@ func (i *apiserviceSpecPatchPtrType) ToAPIServiceSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecPatchPtrOutput) } +func (i *apiserviceSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpecPatch] { + return pulumix.Output[*APIServiceSpecPatch]{ + OutputState: i.ToAPIServiceSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. type APIServiceSpecPatchOutput struct{ *pulumi.OutputState } @@ -974,6 +1107,12 @@ func (o APIServiceSpecPatchOutput) ToAPIServiceSpecPatchPtrOutputWithContext(ctx }).(APIServiceSpecPatchPtrOutput) } +func (o APIServiceSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpecPatch] { + return pulumix.Output[APIServiceSpecPatch]{ + OutputState: o.OutputState, + } +} + // CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. func (o APIServiceSpecPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceSpecPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -1023,6 +1162,12 @@ func (o APIServiceSpecPatchPtrOutput) ToAPIServiceSpecPatchPtrOutputWithContext( return o } +func (o APIServiceSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpecPatch] { + return pulumix.Output[*APIServiceSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o APIServiceSpecPatchPtrOutput) Elem() APIServiceSpecPatchOutput { return o.ApplyT(func(v *APIServiceSpecPatch) APIServiceSpecPatch { if v != nil { @@ -1138,6 +1283,12 @@ func (i APIServiceStatusArgs) ToAPIServiceStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusOutput) } +func (i APIServiceStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatus] { + return pulumix.Output[APIServiceStatus]{ + OutputState: i.ToAPIServiceStatusOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceStatusArgs) ToAPIServiceStatusPtrOutput() APIServiceStatusPtrOutput { return i.ToAPIServiceStatusPtrOutputWithContext(context.Background()) } @@ -1179,6 +1330,12 @@ func (i *apiserviceStatusPtrType) ToAPIServiceStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusPtrOutput) } +func (i *apiserviceStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatus] { + return pulumix.Output[*APIServiceStatus]{ + OutputState: i.ToAPIServiceStatusPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceStatus contains derived information about an API server type APIServiceStatusOutput struct{ *pulumi.OutputState } @@ -1204,6 +1361,12 @@ func (o APIServiceStatusOutput) ToAPIServiceStatusPtrOutputWithContext(ctx conte }).(APIServiceStatusPtrOutput) } +func (o APIServiceStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatus] { + return pulumix.Output[APIServiceStatus]{ + OutputState: o.OutputState, + } +} + // Current service state of apiService. func (o APIServiceStatusOutput) Conditions() APIServiceConditionArrayOutput { return o.ApplyT(func(v APIServiceStatus) []APIServiceCondition { return v.Conditions }).(APIServiceConditionArrayOutput) @@ -1223,6 +1386,12 @@ func (o APIServiceStatusPtrOutput) ToAPIServiceStatusPtrOutputWithContext(ctx co return o } +func (o APIServiceStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatus] { + return pulumix.Output[*APIServiceStatus]{ + OutputState: o.OutputState, + } +} + func (o APIServiceStatusPtrOutput) Elem() APIServiceStatusOutput { return o.ApplyT(func(v *APIServiceStatus) APIServiceStatus { if v != nil { @@ -1278,6 +1447,12 @@ func (i APIServiceStatusPatchArgs) ToAPIServiceStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusPatchOutput) } +func (i APIServiceStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatusPatch] { + return pulumix.Output[APIServiceStatusPatch]{ + OutputState: i.ToAPIServiceStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceStatusPatchArgs) ToAPIServiceStatusPatchPtrOutput() APIServiceStatusPatchPtrOutput { return i.ToAPIServiceStatusPatchPtrOutputWithContext(context.Background()) } @@ -1319,6 +1494,12 @@ func (i *apiserviceStatusPatchPtrType) ToAPIServiceStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusPatchPtrOutput) } +func (i *apiserviceStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatusPatch] { + return pulumix.Output[*APIServiceStatusPatch]{ + OutputState: i.ToAPIServiceStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceStatus contains derived information about an API server type APIServiceStatusPatchOutput struct{ *pulumi.OutputState } @@ -1344,6 +1525,12 @@ func (o APIServiceStatusPatchOutput) ToAPIServiceStatusPatchPtrOutputWithContext }).(APIServiceStatusPatchPtrOutput) } +func (o APIServiceStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatusPatch] { + return pulumix.Output[APIServiceStatusPatch]{ + OutputState: o.OutputState, + } +} + // Current service state of apiService. func (o APIServiceStatusPatchOutput) Conditions() APIServiceConditionPatchArrayOutput { return o.ApplyT(func(v APIServiceStatusPatch) []APIServiceConditionPatch { return v.Conditions }).(APIServiceConditionPatchArrayOutput) @@ -1363,6 +1550,12 @@ func (o APIServiceStatusPatchPtrOutput) ToAPIServiceStatusPatchPtrOutputWithCont return o } +func (o APIServiceStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatusPatch] { + return pulumix.Output[*APIServiceStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o APIServiceStatusPatchPtrOutput) Elem() APIServiceStatusPatchOutput { return o.ApplyT(func(v *APIServiceStatusPatch) APIServiceStatusPatch { if v != nil { @@ -1426,6 +1619,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -1467,6 +1666,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -1492,6 +1697,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // Name is the name of the service func (o ServiceReferenceOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReference) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1521,6 +1732,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -1604,6 +1821,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -1645,6 +1868,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -1670,6 +1899,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // Name is the name of the service func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1699,6 +1934,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { diff --git a/sdk/go/kubernetes/apiregistration/v1beta1/apiservice.go b/sdk/go/kubernetes/apiregistration/v1beta1/apiservice.go index 5f325476e1..af9ed703fb 100644 --- a/sdk/go/kubernetes/apiregistration/v1beta1/apiservice.go +++ b/sdk/go/kubernetes/apiregistration/v1beta1/apiservice.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // APIService represents a server for a particular GroupVersion. Name must be "version.group". @@ -124,6 +125,12 @@ func (i *APIService) ToAPIServiceOutputWithContext(ctx context.Context) APIServi return pulumi.ToOutputWithContext(ctx, i).(APIServiceOutput) } +func (i *APIService) ToOutput(ctx context.Context) pulumix.Output[*APIService] { + return pulumix.Output[*APIService]{ + OutputState: i.ToAPIServiceOutputWithContext(ctx).OutputState, + } +} + // APIServiceArrayInput is an input type that accepts APIServiceArray and APIServiceArrayOutput values. // You can construct a concrete instance of `APIServiceArrayInput` via: // @@ -149,6 +156,12 @@ func (i APIServiceArray) ToAPIServiceArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(APIServiceArrayOutput) } +func (i APIServiceArray) ToOutput(ctx context.Context) pulumix.Output[[]*APIService] { + return pulumix.Output[[]*APIService]{ + OutputState: i.ToAPIServiceArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceMapInput is an input type that accepts APIServiceMap and APIServiceMapOutput values. // You can construct a concrete instance of `APIServiceMapInput` via: // @@ -174,6 +187,12 @@ func (i APIServiceMap) ToAPIServiceMapOutputWithContext(ctx context.Context) API return pulumi.ToOutputWithContext(ctx, i).(APIServiceMapOutput) } +func (i APIServiceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIService] { + return pulumix.Output[map[string]*APIService]{ + OutputState: i.ToAPIServiceMapOutputWithContext(ctx).OutputState, + } +} + type APIServiceOutput struct{ *pulumi.OutputState } func (APIServiceOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o APIServiceOutput) ToAPIServiceOutputWithContext(ctx context.Context) API return o } +func (o APIServiceOutput) ToOutput(ctx context.Context) pulumix.Output[*APIService] { + return pulumix.Output[*APIService]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *APIService) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -226,6 +251,12 @@ func (o APIServiceArrayOutput) ToAPIServiceArrayOutputWithContext(ctx context.Co return o } +func (o APIServiceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*APIService] { + return pulumix.Output[[]*APIService]{ + OutputState: o.OutputState, + } +} + func (o APIServiceArrayOutput) Index(i pulumi.IntInput) APIServiceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *APIService { return vs[0].([]*APIService)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o APIServiceMapOutput) ToAPIServiceMapOutputWithContext(ctx context.Contex return o } +func (o APIServiceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIService] { + return pulumix.Output[map[string]*APIService]{ + OutputState: o.OutputState, + } +} + func (o APIServiceMapOutput) MapIndex(k pulumi.StringInput) APIServiceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *APIService { return vs[0].(map[string]*APIService)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiregistration/v1beta1/apiserviceList.go b/sdk/go/kubernetes/apiregistration/v1beta1/apiserviceList.go index 6125dd5b9e..13b82e4695 100644 --- a/sdk/go/kubernetes/apiregistration/v1beta1/apiserviceList.go +++ b/sdk/go/kubernetes/apiregistration/v1beta1/apiserviceList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // APIServiceList is a list of APIService objects. @@ -117,6 +118,12 @@ func (i *APIServiceList) ToAPIServiceListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(APIServiceListOutput) } +func (i *APIServiceList) ToOutput(ctx context.Context) pulumix.Output[*APIServiceList] { + return pulumix.Output[*APIServiceList]{ + OutputState: i.ToAPIServiceListOutputWithContext(ctx).OutputState, + } +} + // APIServiceListArrayInput is an input type that accepts APIServiceListArray and APIServiceListArrayOutput values. // You can construct a concrete instance of `APIServiceListArrayInput` via: // @@ -142,6 +149,12 @@ func (i APIServiceListArray) ToAPIServiceListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(APIServiceListArrayOutput) } +func (i APIServiceListArray) ToOutput(ctx context.Context) pulumix.Output[[]*APIServiceList] { + return pulumix.Output[[]*APIServiceList]{ + OutputState: i.ToAPIServiceListArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceListMapInput is an input type that accepts APIServiceListMap and APIServiceListMapOutput values. // You can construct a concrete instance of `APIServiceListMapInput` via: // @@ -167,6 +180,12 @@ func (i APIServiceListMap) ToAPIServiceListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(APIServiceListMapOutput) } +func (i APIServiceListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServiceList] { + return pulumix.Output[map[string]*APIServiceList]{ + OutputState: i.ToAPIServiceListMapOutputWithContext(ctx).OutputState, + } +} + type APIServiceListOutput struct{ *pulumi.OutputState } func (APIServiceListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o APIServiceListOutput) ToAPIServiceListOutputWithContext(ctx context.Cont return o } +func (o APIServiceListOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceList] { + return pulumix.Output[*APIServiceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *APIServiceList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -213,6 +238,12 @@ func (o APIServiceListArrayOutput) ToAPIServiceListArrayOutputWithContext(ctx co return o } +func (o APIServiceListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*APIServiceList] { + return pulumix.Output[[]*APIServiceList]{ + OutputState: o.OutputState, + } +} + func (o APIServiceListArrayOutput) Index(i pulumi.IntInput) APIServiceListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *APIServiceList { return vs[0].([]*APIServiceList)[vs[1].(int)] @@ -233,6 +264,12 @@ func (o APIServiceListMapOutput) ToAPIServiceListMapOutputWithContext(ctx contex return o } +func (o APIServiceListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServiceList] { + return pulumix.Output[map[string]*APIServiceList]{ + OutputState: o.OutputState, + } +} + func (o APIServiceListMapOutput) MapIndex(k pulumi.StringInput) APIServiceListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *APIServiceList { return vs[0].(map[string]*APIServiceList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiregistration/v1beta1/apiservicePatch.go b/sdk/go/kubernetes/apiregistration/v1beta1/apiservicePatch.go index 20cdb881c4..61fc03f4f8 100644 --- a/sdk/go/kubernetes/apiregistration/v1beta1/apiservicePatch.go +++ b/sdk/go/kubernetes/apiregistration/v1beta1/apiservicePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *APIServicePatch) ToAPIServicePatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchOutput) } +func (i *APIServicePatch) ToOutput(ctx context.Context) pulumix.Output[*APIServicePatch] { + return pulumix.Output[*APIServicePatch]{ + OutputState: i.ToAPIServicePatchOutputWithContext(ctx).OutputState, + } +} + // APIServicePatchArrayInput is an input type that accepts APIServicePatchArray and APIServicePatchArrayOutput values. // You can construct a concrete instance of `APIServicePatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i APIServicePatchArray) ToAPIServicePatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchArrayOutput) } +func (i APIServicePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*APIServicePatch] { + return pulumix.Output[[]*APIServicePatch]{ + OutputState: i.ToAPIServicePatchArrayOutputWithContext(ctx).OutputState, + } +} + // APIServicePatchMapInput is an input type that accepts APIServicePatchMap and APIServicePatchMapOutput values. // You can construct a concrete instance of `APIServicePatchMapInput` via: // @@ -180,6 +193,12 @@ func (i APIServicePatchMap) ToAPIServicePatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchMapOutput) } +func (i APIServicePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServicePatch] { + return pulumix.Output[map[string]*APIServicePatch]{ + OutputState: i.ToAPIServicePatchMapOutputWithContext(ctx).OutputState, + } +} + type APIServicePatchOutput struct{ *pulumi.OutputState } func (APIServicePatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o APIServicePatchOutput) ToAPIServicePatchOutputWithContext(ctx context.Co return o } +func (o APIServicePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServicePatch] { + return pulumix.Output[*APIServicePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServicePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *APIServicePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -232,6 +257,12 @@ func (o APIServicePatchArrayOutput) ToAPIServicePatchArrayOutputWithContext(ctx return o } +func (o APIServicePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*APIServicePatch] { + return pulumix.Output[[]*APIServicePatch]{ + OutputState: o.OutputState, + } +} + func (o APIServicePatchArrayOutput) Index(i pulumi.IntInput) APIServicePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *APIServicePatch { return vs[0].([]*APIServicePatch)[vs[1].(int)] @@ -252,6 +283,12 @@ func (o APIServicePatchMapOutput) ToAPIServicePatchMapOutputWithContext(ctx cont return o } +func (o APIServicePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*APIServicePatch] { + return pulumix.Output[map[string]*APIServicePatch]{ + OutputState: o.OutputState, + } +} + func (o APIServicePatchMapOutput) MapIndex(k pulumi.StringInput) APIServicePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *APIServicePatch { return vs[0].(map[string]*APIServicePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apiregistration/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/apiregistration/v1beta1/pulumiTypes.go index 830a94202c..2daa740a7e 100644 --- a/sdk/go/kubernetes/apiregistration/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/apiregistration/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -63,6 +64,12 @@ func (i APIServiceTypeArgs) ToAPIServiceTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(APIServiceTypeOutput) } +func (i APIServiceTypeArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceType] { + return pulumix.Output[APIServiceType]{ + OutputState: i.ToAPIServiceTypeOutputWithContext(ctx).OutputState, + } +} + // APIServiceTypeArrayInput is an input type that accepts APIServiceTypeArray and APIServiceTypeArrayOutput values. // You can construct a concrete instance of `APIServiceTypeArrayInput` via: // @@ -88,6 +95,12 @@ func (i APIServiceTypeArray) ToAPIServiceTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(APIServiceTypeArrayOutput) } +func (i APIServiceTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceType] { + return pulumix.Output[[]APIServiceType]{ + OutputState: i.ToAPIServiceTypeArrayOutputWithContext(ctx).OutputState, + } +} + // APIService represents a server for a particular GroupVersion. Name must be "version.group". type APIServiceTypeOutput struct{ *pulumi.OutputState } @@ -103,6 +116,12 @@ func (o APIServiceTypeOutput) ToAPIServiceTypeOutputWithContext(ctx context.Cont return o } +func (o APIServiceTypeOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceType] { + return pulumix.Output[APIServiceType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -141,6 +160,12 @@ func (o APIServiceTypeArrayOutput) ToAPIServiceTypeArrayOutputWithContext(ctx co return o } +func (o APIServiceTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceType] { + return pulumix.Output[[]APIServiceType]{ + OutputState: o.OutputState, + } +} + func (o APIServiceTypeArrayOutput) Index(i pulumi.IntInput) APIServiceTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIServiceType { return vs[0].([]APIServiceType)[vs[1].(int)] @@ -198,6 +223,12 @@ func (i APIServiceConditionArgs) ToAPIServiceConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionOutput) } +func (i APIServiceConditionArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceCondition] { + return pulumix.Output[APIServiceCondition]{ + OutputState: i.ToAPIServiceConditionOutputWithContext(ctx).OutputState, + } +} + // APIServiceConditionArrayInput is an input type that accepts APIServiceConditionArray and APIServiceConditionArrayOutput values. // You can construct a concrete instance of `APIServiceConditionArrayInput` via: // @@ -223,6 +254,12 @@ func (i APIServiceConditionArray) ToAPIServiceConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionArrayOutput) } +func (i APIServiceConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceCondition] { + return pulumix.Output[[]APIServiceCondition]{ + OutputState: i.ToAPIServiceConditionArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceCondition describes the state of an APIService at a particular point type APIServiceConditionOutput struct{ *pulumi.OutputState } @@ -238,6 +275,12 @@ func (o APIServiceConditionOutput) ToAPIServiceConditionOutputWithContext(ctx co return o } +func (o APIServiceConditionOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceCondition] { + return pulumix.Output[APIServiceCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o APIServiceConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -277,6 +320,12 @@ func (o APIServiceConditionArrayOutput) ToAPIServiceConditionArrayOutputWithCont return o } +func (o APIServiceConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceCondition] { + return pulumix.Output[[]APIServiceCondition]{ + OutputState: o.OutputState, + } +} + func (o APIServiceConditionArrayOutput) Index(i pulumi.IntInput) APIServiceConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIServiceCondition { return vs[0].([]APIServiceCondition)[vs[1].(int)] @@ -334,6 +383,12 @@ func (i APIServiceConditionPatchArgs) ToAPIServiceConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionPatchOutput) } +func (i APIServiceConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceConditionPatch] { + return pulumix.Output[APIServiceConditionPatch]{ + OutputState: i.ToAPIServiceConditionPatchOutputWithContext(ctx).OutputState, + } +} + // APIServiceConditionPatchArrayInput is an input type that accepts APIServiceConditionPatchArray and APIServiceConditionPatchArrayOutput values. // You can construct a concrete instance of `APIServiceConditionPatchArrayInput` via: // @@ -359,6 +414,12 @@ func (i APIServiceConditionPatchArray) ToAPIServiceConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(APIServiceConditionPatchArrayOutput) } +func (i APIServiceConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceConditionPatch] { + return pulumix.Output[[]APIServiceConditionPatch]{ + OutputState: i.ToAPIServiceConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // APIServiceCondition describes the state of an APIService at a particular point type APIServiceConditionPatchOutput struct{ *pulumi.OutputState } @@ -374,6 +435,12 @@ func (o APIServiceConditionPatchOutput) ToAPIServiceConditionPatchOutputWithCont return o } +func (o APIServiceConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceConditionPatch] { + return pulumix.Output[APIServiceConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o APIServiceConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -413,6 +480,12 @@ func (o APIServiceConditionPatchArrayOutput) ToAPIServiceConditionPatchArrayOutp return o } +func (o APIServiceConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIServiceConditionPatch] { + return pulumix.Output[[]APIServiceConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o APIServiceConditionPatchArrayOutput) Index(i pulumi.IntInput) APIServiceConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIServiceConditionPatch { return vs[0].([]APIServiceConditionPatch)[vs[1].(int)] @@ -462,6 +535,12 @@ func (i APIServiceListTypeArgs) ToAPIServiceListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(APIServiceListTypeOutput) } +func (i APIServiceListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceListType] { + return pulumix.Output[APIServiceListType]{ + OutputState: i.ToAPIServiceListTypeOutputWithContext(ctx).OutputState, + } +} + // APIServiceList is a list of APIService objects. type APIServiceListTypeOutput struct{ *pulumi.OutputState } @@ -477,6 +556,12 @@ func (o APIServiceListTypeOutput) ToAPIServiceListTypeOutputWithContext(ctx cont return o } +func (o APIServiceListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceListType] { + return pulumix.Output[APIServiceListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServiceListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -544,6 +629,12 @@ func (i APIServicePatchTypeArgs) ToAPIServicePatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(APIServicePatchTypeOutput) } +func (i APIServicePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[APIServicePatchType] { + return pulumix.Output[APIServicePatchType]{ + OutputState: i.ToAPIServicePatchTypeOutputWithContext(ctx).OutputState, + } +} + // APIService represents a server for a particular GroupVersion. Name must be "version.group". type APIServicePatchTypeOutput struct{ *pulumi.OutputState } @@ -559,6 +650,12 @@ func (o APIServicePatchTypeOutput) ToAPIServicePatchTypeOutputWithContext(ctx co return o } +func (o APIServicePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[APIServicePatchType] { + return pulumix.Output[APIServicePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIServicePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServicePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -642,6 +739,12 @@ func (i APIServiceSpecArgs) ToAPIServiceSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecOutput) } +func (i APIServiceSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpec] { + return pulumix.Output[APIServiceSpec]{ + OutputState: i.ToAPIServiceSpecOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceSpecArgs) ToAPIServiceSpecPtrOutput() APIServiceSpecPtrOutput { return i.ToAPIServiceSpecPtrOutputWithContext(context.Background()) } @@ -683,6 +786,12 @@ func (i *apiserviceSpecPtrType) ToAPIServiceSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecPtrOutput) } +func (i *apiserviceSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpec] { + return pulumix.Output[*APIServiceSpec]{ + OutputState: i.ToAPIServiceSpecPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. type APIServiceSpecOutput struct{ *pulumi.OutputState } @@ -708,6 +817,12 @@ func (o APIServiceSpecOutput) ToAPIServiceSpecPtrOutputWithContext(ctx context.C }).(APIServiceSpecPtrOutput) } +func (o APIServiceSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpec] { + return pulumix.Output[APIServiceSpec]{ + OutputState: o.OutputState, + } +} + // CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. func (o APIServiceSpecOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceSpec) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -757,6 +872,12 @@ func (o APIServiceSpecPtrOutput) ToAPIServiceSpecPtrOutputWithContext(ctx contex return o } +func (o APIServiceSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpec] { + return pulumix.Output[*APIServiceSpec]{ + OutputState: o.OutputState, + } +} + func (o APIServiceSpecPtrOutput) Elem() APIServiceSpecOutput { return o.ApplyT(func(v *APIServiceSpec) APIServiceSpec { if v != nil { @@ -896,6 +1017,12 @@ func (i APIServiceSpecPatchArgs) ToAPIServiceSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecPatchOutput) } +func (i APIServiceSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpecPatch] { + return pulumix.Output[APIServiceSpecPatch]{ + OutputState: i.ToAPIServiceSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceSpecPatchArgs) ToAPIServiceSpecPatchPtrOutput() APIServiceSpecPatchPtrOutput { return i.ToAPIServiceSpecPatchPtrOutputWithContext(context.Background()) } @@ -937,6 +1064,12 @@ func (i *apiserviceSpecPatchPtrType) ToAPIServiceSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(APIServiceSpecPatchPtrOutput) } +func (i *apiserviceSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpecPatch] { + return pulumix.Output[*APIServiceSpecPatch]{ + OutputState: i.ToAPIServiceSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. type APIServiceSpecPatchOutput struct{ *pulumi.OutputState } @@ -962,6 +1095,12 @@ func (o APIServiceSpecPatchOutput) ToAPIServiceSpecPatchPtrOutputWithContext(ctx }).(APIServiceSpecPatchPtrOutput) } +func (o APIServiceSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceSpecPatch] { + return pulumix.Output[APIServiceSpecPatch]{ + OutputState: o.OutputState, + } +} + // CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. func (o APIServiceSpecPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v APIServiceSpecPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -1011,6 +1150,12 @@ func (o APIServiceSpecPatchPtrOutput) ToAPIServiceSpecPatchPtrOutputWithContext( return o } +func (o APIServiceSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceSpecPatch] { + return pulumix.Output[*APIServiceSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o APIServiceSpecPatchPtrOutput) Elem() APIServiceSpecPatchOutput { return o.ApplyT(func(v *APIServiceSpecPatch) APIServiceSpecPatch { if v != nil { @@ -1126,6 +1271,12 @@ func (i APIServiceStatusArgs) ToAPIServiceStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusOutput) } +func (i APIServiceStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatus] { + return pulumix.Output[APIServiceStatus]{ + OutputState: i.ToAPIServiceStatusOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceStatusArgs) ToAPIServiceStatusPtrOutput() APIServiceStatusPtrOutput { return i.ToAPIServiceStatusPtrOutputWithContext(context.Background()) } @@ -1167,6 +1318,12 @@ func (i *apiserviceStatusPtrType) ToAPIServiceStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusPtrOutput) } +func (i *apiserviceStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatus] { + return pulumix.Output[*APIServiceStatus]{ + OutputState: i.ToAPIServiceStatusPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceStatus contains derived information about an API server type APIServiceStatusOutput struct{ *pulumi.OutputState } @@ -1192,6 +1349,12 @@ func (o APIServiceStatusOutput) ToAPIServiceStatusPtrOutputWithContext(ctx conte }).(APIServiceStatusPtrOutput) } +func (o APIServiceStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatus] { + return pulumix.Output[APIServiceStatus]{ + OutputState: o.OutputState, + } +} + // Current service state of apiService. func (o APIServiceStatusOutput) Conditions() APIServiceConditionArrayOutput { return o.ApplyT(func(v APIServiceStatus) []APIServiceCondition { return v.Conditions }).(APIServiceConditionArrayOutput) @@ -1211,6 +1374,12 @@ func (o APIServiceStatusPtrOutput) ToAPIServiceStatusPtrOutputWithContext(ctx co return o } +func (o APIServiceStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatus] { + return pulumix.Output[*APIServiceStatus]{ + OutputState: o.OutputState, + } +} + func (o APIServiceStatusPtrOutput) Elem() APIServiceStatusOutput { return o.ApplyT(func(v *APIServiceStatus) APIServiceStatus { if v != nil { @@ -1266,6 +1435,12 @@ func (i APIServiceStatusPatchArgs) ToAPIServiceStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusPatchOutput) } +func (i APIServiceStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatusPatch] { + return pulumix.Output[APIServiceStatusPatch]{ + OutputState: i.ToAPIServiceStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i APIServiceStatusPatchArgs) ToAPIServiceStatusPatchPtrOutput() APIServiceStatusPatchPtrOutput { return i.ToAPIServiceStatusPatchPtrOutputWithContext(context.Background()) } @@ -1307,6 +1482,12 @@ func (i *apiserviceStatusPatchPtrType) ToAPIServiceStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(APIServiceStatusPatchPtrOutput) } +func (i *apiserviceStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatusPatch] { + return pulumix.Output[*APIServiceStatusPatch]{ + OutputState: i.ToAPIServiceStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // APIServiceStatus contains derived information about an API server type APIServiceStatusPatchOutput struct{ *pulumi.OutputState } @@ -1332,6 +1513,12 @@ func (o APIServiceStatusPatchOutput) ToAPIServiceStatusPatchPtrOutputWithContext }).(APIServiceStatusPatchPtrOutput) } +func (o APIServiceStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIServiceStatusPatch] { + return pulumix.Output[APIServiceStatusPatch]{ + OutputState: o.OutputState, + } +} + // Current service state of apiService. func (o APIServiceStatusPatchOutput) Conditions() APIServiceConditionPatchArrayOutput { return o.ApplyT(func(v APIServiceStatusPatch) []APIServiceConditionPatch { return v.Conditions }).(APIServiceConditionPatchArrayOutput) @@ -1351,6 +1538,12 @@ func (o APIServiceStatusPatchPtrOutput) ToAPIServiceStatusPatchPtrOutputWithCont return o } +func (o APIServiceStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIServiceStatusPatch] { + return pulumix.Output[*APIServiceStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o APIServiceStatusPatchPtrOutput) Elem() APIServiceStatusPatchOutput { return o.ApplyT(func(v *APIServiceStatusPatch) APIServiceStatusPatch { if v != nil { @@ -1414,6 +1607,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -1455,6 +1654,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -1480,6 +1685,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // Name is the name of the service func (o ServiceReferenceOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReference) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1509,6 +1720,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -1592,6 +1809,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -1633,6 +1856,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -1658,6 +1887,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // Name is the name of the service func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1687,6 +1922,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { diff --git a/sdk/go/kubernetes/apps/v1/controllerRevision.go b/sdk/go/kubernetes/apps/v1/controllerRevision.go index 057ad51cb6..cd77c99522 100644 --- a/sdk/go/kubernetes/apps/v1/controllerRevision.go +++ b/sdk/go/kubernetes/apps/v1/controllerRevision.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. @@ -132,6 +133,12 @@ func (i *ControllerRevision) ToControllerRevisionOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionOutput) } +func (i *ControllerRevision) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevision] { + return pulumix.Output[*ControllerRevision]{ + OutputState: i.ToControllerRevisionOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionArrayInput is an input type that accepts ControllerRevisionArray and ControllerRevisionArrayOutput values. // You can construct a concrete instance of `ControllerRevisionArrayInput` via: // @@ -157,6 +164,12 @@ func (i ControllerRevisionArray) ToControllerRevisionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionArrayOutput) } +func (i ControllerRevisionArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevision] { + return pulumix.Output[[]*ControllerRevision]{ + OutputState: i.ToControllerRevisionArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionMapInput is an input type that accepts ControllerRevisionMap and ControllerRevisionMapOutput values. // You can construct a concrete instance of `ControllerRevisionMapInput` via: // @@ -182,6 +195,12 @@ func (i ControllerRevisionMap) ToControllerRevisionMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionMapOutput) } +func (i ControllerRevisionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevision] { + return pulumix.Output[map[string]*ControllerRevision]{ + OutputState: i.ToControllerRevisionMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionOutput struct{ *pulumi.OutputState } func (ControllerRevisionOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o ControllerRevisionOutput) ToControllerRevisionOutputWithContext(ctx cont return o } +func (o ControllerRevisionOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevision] { + return pulumix.Output[*ControllerRevision]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ControllerRevision) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o ControllerRevisionArrayOutput) ToControllerRevisionArrayOutputWithContex return o } +func (o ControllerRevisionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevision] { + return pulumix.Output[[]*ControllerRevision]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionArrayOutput) Index(i pulumi.IntInput) ControllerRevisionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevision { return vs[0].([]*ControllerRevision)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o ControllerRevisionMapOutput) ToControllerRevisionMapOutputWithContext(ct return o } +func (o ControllerRevisionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevision] { + return pulumix.Output[map[string]*ControllerRevision]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevision { return vs[0].(map[string]*ControllerRevision)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/controllerRevisionList.go b/sdk/go/kubernetes/apps/v1/controllerRevisionList.go index ffebb90109..eb3f1e257e 100644 --- a/sdk/go/kubernetes/apps/v1/controllerRevisionList.go +++ b/sdk/go/kubernetes/apps/v1/controllerRevisionList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ControllerRevisionList is a resource containing a list of ControllerRevision objects. @@ -117,6 +118,12 @@ func (i *ControllerRevisionList) ToControllerRevisionListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListOutput) } +func (i *ControllerRevisionList) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionList] { + return pulumix.Output[*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionListArrayInput is an input type that accepts ControllerRevisionListArray and ControllerRevisionListArrayOutput values. // You can construct a concrete instance of `ControllerRevisionListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ControllerRevisionListArray) ToControllerRevisionListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListArrayOutput) } +func (i ControllerRevisionListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionList] { + return pulumix.Output[[]*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionListMapInput is an input type that accepts ControllerRevisionListMap and ControllerRevisionListMapOutput values. // You can construct a concrete instance of `ControllerRevisionListMapInput` via: // @@ -167,6 +180,12 @@ func (i ControllerRevisionListMap) ToControllerRevisionListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListMapOutput) } +func (i ControllerRevisionListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionList] { + return pulumix.Output[map[string]*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionListOutput struct{ *pulumi.OutputState } func (ControllerRevisionListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ControllerRevisionListOutput) ToControllerRevisionListOutputWithContext( return o } +func (o ControllerRevisionListOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionList] { + return pulumix.Output[*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ControllerRevisionList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ControllerRevisionListArrayOutput) ToControllerRevisionListArrayOutputWi return o } +func (o ControllerRevisionListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionList] { + return pulumix.Output[[]*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionListArrayOutput) Index(i pulumi.IntInput) ControllerRevisionListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevisionList { return vs[0].([]*ControllerRevisionList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ControllerRevisionListMapOutput) ToControllerRevisionListMapOutputWithCo return o } +func (o ControllerRevisionListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionList] { + return pulumix.Output[map[string]*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionListMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevisionList { return vs[0].(map[string]*ControllerRevisionList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/controllerRevisionPatch.go b/sdk/go/kubernetes/apps/v1/controllerRevisionPatch.go index 8d874393a8..7f4d32d694 100644 --- a/sdk/go/kubernetes/apps/v1/controllerRevisionPatch.go +++ b/sdk/go/kubernetes/apps/v1/controllerRevisionPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ControllerRevisionPatch) ToControllerRevisionPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchOutput) } +func (i *ControllerRevisionPatch) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionPatch] { + return pulumix.Output[*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionPatchArrayInput is an input type that accepts ControllerRevisionPatchArray and ControllerRevisionPatchArrayOutput values. // You can construct a concrete instance of `ControllerRevisionPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ControllerRevisionPatchArray) ToControllerRevisionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchArrayOutput) } +func (i ControllerRevisionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionPatch] { + return pulumix.Output[[]*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionPatchMapInput is an input type that accepts ControllerRevisionPatchMap and ControllerRevisionPatchMapOutput values. // You can construct a concrete instance of `ControllerRevisionPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ControllerRevisionPatchMap) ToControllerRevisionPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchMapOutput) } +func (i ControllerRevisionPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionPatch] { + return pulumix.Output[map[string]*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionPatchOutput struct{ *pulumi.OutputState } func (ControllerRevisionPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ControllerRevisionPatchOutput) ToControllerRevisionPatchOutputWithContex return o } +func (o ControllerRevisionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionPatch] { + return pulumix.Output[*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ControllerRevisionPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o ControllerRevisionPatchArrayOutput) ToControllerRevisionPatchArrayOutput return o } +func (o ControllerRevisionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionPatch] { + return pulumix.Output[[]*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionPatchArrayOutput) Index(i pulumi.IntInput) ControllerRevisionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevisionPatch { return vs[0].([]*ControllerRevisionPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ControllerRevisionPatchMapOutput) ToControllerRevisionPatchMapOutputWith return o } +func (o ControllerRevisionPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionPatch] { + return pulumix.Output[map[string]*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionPatchMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevisionPatch { return vs[0].(map[string]*ControllerRevisionPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/daemonSet.go b/sdk/go/kubernetes/apps/v1/daemonSet.go index 147b87dcb3..7b93a5da15 100644 --- a/sdk/go/kubernetes/apps/v1/daemonSet.go +++ b/sdk/go/kubernetes/apps/v1/daemonSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DaemonSet represents the configuration of a daemon set. @@ -124,6 +125,12 @@ func (i *DaemonSet) ToDaemonSetOutputWithContext(ctx context.Context) DaemonSetO return pulumi.ToOutputWithContext(ctx, i).(DaemonSetOutput) } +func (i *DaemonSet) ToOutput(ctx context.Context) pulumix.Output[*DaemonSet] { + return pulumix.Output[*DaemonSet]{ + OutputState: i.ToDaemonSetOutputWithContext(ctx).OutputState, + } +} + // DaemonSetArrayInput is an input type that accepts DaemonSetArray and DaemonSetArrayOutput values. // You can construct a concrete instance of `DaemonSetArrayInput` via: // @@ -149,6 +156,12 @@ func (i DaemonSetArray) ToDaemonSetArrayOutputWithContext(ctx context.Context) D return pulumi.ToOutputWithContext(ctx, i).(DaemonSetArrayOutput) } +func (i DaemonSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSet] { + return pulumix.Output[[]*DaemonSet]{ + OutputState: i.ToDaemonSetArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetMapInput is an input type that accepts DaemonSetMap and DaemonSetMapOutput values. // You can construct a concrete instance of `DaemonSetMapInput` via: // @@ -174,6 +187,12 @@ func (i DaemonSetMap) ToDaemonSetMapOutputWithContext(ctx context.Context) Daemo return pulumi.ToOutputWithContext(ctx, i).(DaemonSetMapOutput) } +func (i DaemonSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSet] { + return pulumix.Output[map[string]*DaemonSet]{ + OutputState: i.ToDaemonSetMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetOutput struct{ *pulumi.OutputState } func (DaemonSetOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o DaemonSetOutput) ToDaemonSetOutputWithContext(ctx context.Context) Daemo return o } +func (o DaemonSetOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSet] { + return pulumix.Output[*DaemonSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DaemonSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -227,6 +252,12 @@ func (o DaemonSetArrayOutput) ToDaemonSetArrayOutputWithContext(ctx context.Cont return o } +func (o DaemonSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSet] { + return pulumix.Output[[]*DaemonSet]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetArrayOutput) Index(i pulumi.IntInput) DaemonSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSet { return vs[0].([]*DaemonSet)[vs[1].(int)] @@ -247,6 +278,12 @@ func (o DaemonSetMapOutput) ToDaemonSetMapOutputWithContext(ctx context.Context) return o } +func (o DaemonSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSet] { + return pulumix.Output[map[string]*DaemonSet]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetMapOutput) MapIndex(k pulumi.StringInput) DaemonSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSet { return vs[0].(map[string]*DaemonSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/daemonSetList.go b/sdk/go/kubernetes/apps/v1/daemonSetList.go index 68a5c556ad..13fd3d2f6c 100644 --- a/sdk/go/kubernetes/apps/v1/daemonSetList.go +++ b/sdk/go/kubernetes/apps/v1/daemonSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DaemonSetList is a collection of daemon sets. @@ -117,6 +118,12 @@ func (i *DaemonSetList) ToDaemonSetListOutputWithContext(ctx context.Context) Da return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListOutput) } +func (i *DaemonSetList) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetList] { + return pulumix.Output[*DaemonSetList]{ + OutputState: i.ToDaemonSetListOutputWithContext(ctx).OutputState, + } +} + // DaemonSetListArrayInput is an input type that accepts DaemonSetListArray and DaemonSetListArrayOutput values. // You can construct a concrete instance of `DaemonSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DaemonSetListArray) ToDaemonSetListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListArrayOutput) } +func (i DaemonSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetList] { + return pulumix.Output[[]*DaemonSetList]{ + OutputState: i.ToDaemonSetListArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetListMapInput is an input type that accepts DaemonSetListMap and DaemonSetListMapOutput values. // You can construct a concrete instance of `DaemonSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i DaemonSetListMap) ToDaemonSetListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListMapOutput) } +func (i DaemonSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetList] { + return pulumix.Output[map[string]*DaemonSetList]{ + OutputState: i.ToDaemonSetListMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetListOutput struct{ *pulumi.OutputState } func (DaemonSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DaemonSetListOutput) ToDaemonSetListOutputWithContext(ctx context.Contex return o } +func (o DaemonSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetList] { + return pulumix.Output[*DaemonSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DaemonSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DaemonSetListArrayOutput) ToDaemonSetListArrayOutputWithContext(ctx cont return o } +func (o DaemonSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetList] { + return pulumix.Output[[]*DaemonSetList]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetListArrayOutput) Index(i pulumi.IntInput) DaemonSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSetList { return vs[0].([]*DaemonSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DaemonSetListMapOutput) ToDaemonSetListMapOutputWithContext(ctx context. return o } +func (o DaemonSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetList] { + return pulumix.Output[map[string]*DaemonSetList]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetListMapOutput) MapIndex(k pulumi.StringInput) DaemonSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSetList { return vs[0].(map[string]*DaemonSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/daemonSetPatch.go b/sdk/go/kubernetes/apps/v1/daemonSetPatch.go index f6f57d4cb1..e07b0161f9 100644 --- a/sdk/go/kubernetes/apps/v1/daemonSetPatch.go +++ b/sdk/go/kubernetes/apps/v1/daemonSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *DaemonSetPatch) ToDaemonSetPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchOutput) } +func (i *DaemonSetPatch) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetPatch] { + return pulumix.Output[*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchOutputWithContext(ctx).OutputState, + } +} + // DaemonSetPatchArrayInput is an input type that accepts DaemonSetPatchArray and DaemonSetPatchArrayOutput values. // You can construct a concrete instance of `DaemonSetPatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i DaemonSetPatchArray) ToDaemonSetPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchArrayOutput) } +func (i DaemonSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetPatch] { + return pulumix.Output[[]*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetPatchMapInput is an input type that accepts DaemonSetPatchMap and DaemonSetPatchMapOutput values. // You can construct a concrete instance of `DaemonSetPatchMapInput` via: // @@ -180,6 +193,12 @@ func (i DaemonSetPatchMap) ToDaemonSetPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchMapOutput) } +func (i DaemonSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetPatch] { + return pulumix.Output[map[string]*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetPatchOutput struct{ *pulumi.OutputState } func (DaemonSetPatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o DaemonSetPatchOutput) ToDaemonSetPatchOutputWithContext(ctx context.Cont return o } +func (o DaemonSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetPatch] { + return pulumix.Output[*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DaemonSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -233,6 +258,12 @@ func (o DaemonSetPatchArrayOutput) ToDaemonSetPatchArrayOutputWithContext(ctx co return o } +func (o DaemonSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetPatch] { + return pulumix.Output[[]*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetPatchArrayOutput) Index(i pulumi.IntInput) DaemonSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSetPatch { return vs[0].([]*DaemonSetPatch)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o DaemonSetPatchMapOutput) ToDaemonSetPatchMapOutputWithContext(ctx contex return o } +func (o DaemonSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetPatch] { + return pulumix.Output[map[string]*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetPatchMapOutput) MapIndex(k pulumi.StringInput) DaemonSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSetPatch { return vs[0].(map[string]*DaemonSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/deployment.go b/sdk/go/kubernetes/apps/v1/deployment.go index 9399795cbe..fbd9729ae2 100644 --- a/sdk/go/kubernetes/apps/v1/deployment.go +++ b/sdk/go/kubernetes/apps/v1/deployment.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Deployment enables declarative updates for Pods and ReplicaSets. @@ -268,6 +269,12 @@ func (i *Deployment) ToDeploymentOutputWithContext(ctx context.Context) Deployme return pulumi.ToOutputWithContext(ctx, i).(DeploymentOutput) } +func (i *Deployment) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: i.ToDeploymentOutputWithContext(ctx).OutputState, + } +} + // DeploymentArrayInput is an input type that accepts DeploymentArray and DeploymentArrayOutput values. // You can construct a concrete instance of `DeploymentArrayInput` via: // @@ -293,6 +300,12 @@ func (i DeploymentArray) ToDeploymentArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentArrayOutput) } +func (i DeploymentArray) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: i.ToDeploymentArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentMapInput is an input type that accepts DeploymentMap and DeploymentMapOutput values. // You can construct a concrete instance of `DeploymentMapInput` via: // @@ -318,6 +331,12 @@ func (i DeploymentMap) ToDeploymentMapOutputWithContext(ctx context.Context) Dep return pulumi.ToOutputWithContext(ctx, i).(DeploymentMapOutput) } +func (i DeploymentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: i.ToDeploymentMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentOutput struct{ *pulumi.OutputState } func (DeploymentOutput) ElementType() reflect.Type { @@ -332,6 +351,12 @@ func (o DeploymentOutput) ToDeploymentOutputWithContext(ctx context.Context) Dep return o } +func (o DeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Deployment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -371,6 +396,12 @@ func (o DeploymentArrayOutput) ToDeploymentArrayOutputWithContext(ctx context.Co return o } +func (o DeploymentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentArrayOutput) Index(i pulumi.IntInput) DeploymentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Deployment { return vs[0].([]*Deployment)[vs[1].(int)] @@ -391,6 +422,12 @@ func (o DeploymentMapOutput) ToDeploymentMapOutputWithContext(ctx context.Contex return o } +func (o DeploymentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentMapOutput) MapIndex(k pulumi.StringInput) DeploymentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Deployment { return vs[0].(map[string]*Deployment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/deploymentList.go b/sdk/go/kubernetes/apps/v1/deploymentList.go index 8c26ce50c1..032dee201d 100644 --- a/sdk/go/kubernetes/apps/v1/deploymentList.go +++ b/sdk/go/kubernetes/apps/v1/deploymentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DeploymentList is a list of Deployments. @@ -117,6 +118,12 @@ func (i *DeploymentList) ToDeploymentListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentListOutput) } +func (i *DeploymentList) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: i.ToDeploymentListOutputWithContext(ctx).OutputState, + } +} + // DeploymentListArrayInput is an input type that accepts DeploymentListArray and DeploymentListArrayOutput values. // You can construct a concrete instance of `DeploymentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DeploymentListArray) ToDeploymentListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentListArrayOutput) } +func (i DeploymentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: i.ToDeploymentListArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentListMapInput is an input type that accepts DeploymentListMap and DeploymentListMapOutput values. // You can construct a concrete instance of `DeploymentListMapInput` via: // @@ -167,6 +180,12 @@ func (i DeploymentListMap) ToDeploymentListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentListMapOutput) } +func (i DeploymentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: i.ToDeploymentListMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentListOutput struct{ *pulumi.OutputState } func (DeploymentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DeploymentListOutput) ToDeploymentListOutputWithContext(ctx context.Cont return o } +func (o DeploymentListOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DeploymentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DeploymentListArrayOutput) ToDeploymentListArrayOutputWithContext(ctx co return o } +func (o DeploymentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListArrayOutput) Index(i pulumi.IntInput) DeploymentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].([]*DeploymentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DeploymentListMapOutput) ToDeploymentListMapOutputWithContext(ctx contex return o } +func (o DeploymentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListMapOutput) MapIndex(k pulumi.StringInput) DeploymentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].(map[string]*DeploymentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/deploymentPatch.go b/sdk/go/kubernetes/apps/v1/deploymentPatch.go index 468654021a..8f901bf7bf 100644 --- a/sdk/go/kubernetes/apps/v1/deploymentPatch.go +++ b/sdk/go/kubernetes/apps/v1/deploymentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -155,6 +156,12 @@ func (i *DeploymentPatch) ToDeploymentPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchOutput) } +func (i *DeploymentPatch) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchArrayInput is an input type that accepts DeploymentPatchArray and DeploymentPatchArrayOutput values. // You can construct a concrete instance of `DeploymentPatchArrayInput` via: // @@ -180,6 +187,12 @@ func (i DeploymentPatchArray) ToDeploymentPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchArrayOutput) } +func (i DeploymentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchMapInput is an input type that accepts DeploymentPatchMap and DeploymentPatchMapOutput values. // You can construct a concrete instance of `DeploymentPatchMapInput` via: // @@ -205,6 +218,12 @@ func (i DeploymentPatchMap) ToDeploymentPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchMapOutput) } +func (i DeploymentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentPatchOutput struct{ *pulumi.OutputState } func (DeploymentPatchOutput) ElementType() reflect.Type { @@ -219,6 +238,12 @@ func (o DeploymentPatchOutput) ToDeploymentPatchOutputWithContext(ctx context.Co return o } +func (o DeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DeploymentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -258,6 +283,12 @@ func (o DeploymentPatchArrayOutput) ToDeploymentPatchArrayOutputWithContext(ctx return o } +func (o DeploymentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchArrayOutput) Index(i pulumi.IntInput) DeploymentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].([]*DeploymentPatch)[vs[1].(int)] @@ -278,6 +309,12 @@ func (o DeploymentPatchMapOutput) ToDeploymentPatchMapOutputWithContext(ctx cont return o } +func (o DeploymentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchMapOutput) MapIndex(k pulumi.StringInput) DeploymentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].(map[string]*DeploymentPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/pulumiTypes.go b/sdk/go/kubernetes/apps/v1/pulumiTypes.go index 1d42cfeb9a..591e50fb65 100644 --- a/sdk/go/kubernetes/apps/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/apps/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -66,6 +67,12 @@ func (i ControllerRevisionTypeArgs) ToControllerRevisionTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionTypeOutput) } +func (i ControllerRevisionTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionType] { + return pulumix.Output[ControllerRevisionType]{ + OutputState: i.ToControllerRevisionTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionTypeArrayInput is an input type that accepts ControllerRevisionTypeArray and ControllerRevisionTypeArrayOutput values. // You can construct a concrete instance of `ControllerRevisionTypeArrayInput` via: // @@ -91,6 +98,12 @@ func (i ControllerRevisionTypeArray) ToControllerRevisionTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionTypeArrayOutput) } +func (i ControllerRevisionTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ControllerRevisionType] { + return pulumix.Output[[]ControllerRevisionType]{ + OutputState: i.ToControllerRevisionTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. type ControllerRevisionTypeOutput struct{ *pulumi.OutputState } @@ -106,6 +119,12 @@ func (o ControllerRevisionTypeOutput) ToControllerRevisionTypeOutputWithContext( return o } +func (o ControllerRevisionTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionType] { + return pulumix.Output[ControllerRevisionType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -145,6 +164,12 @@ func (o ControllerRevisionTypeArrayOutput) ToControllerRevisionTypeArrayOutputWi return o } +func (o ControllerRevisionTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ControllerRevisionType] { + return pulumix.Output[[]ControllerRevisionType]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionTypeArrayOutput) Index(i pulumi.IntInput) ControllerRevisionTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ControllerRevisionType { return vs[0].([]ControllerRevisionType)[vs[1].(int)] @@ -198,6 +223,12 @@ func (i ControllerRevisionListTypeArgs) ToControllerRevisionListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListTypeOutput) } +func (i ControllerRevisionListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionListType] { + return pulumix.Output[ControllerRevisionListType]{ + OutputState: i.ToControllerRevisionListTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionList is a resource containing a list of ControllerRevision objects. type ControllerRevisionListTypeOutput struct{ *pulumi.OutputState } @@ -213,6 +244,12 @@ func (o ControllerRevisionListTypeOutput) ToControllerRevisionListTypeOutputWith return o } +func (o ControllerRevisionListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionListType] { + return pulumix.Output[ControllerRevisionListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -284,6 +321,12 @@ func (i ControllerRevisionPatchTypeArgs) ToControllerRevisionPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchTypeOutput) } +func (i ControllerRevisionPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionPatchType] { + return pulumix.Output[ControllerRevisionPatchType]{ + OutputState: i.ToControllerRevisionPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. type ControllerRevisionPatchTypeOutput struct{ *pulumi.OutputState } @@ -299,6 +342,12 @@ func (o ControllerRevisionPatchTypeOutput) ToControllerRevisionPatchTypeOutputWi return o } +func (o ControllerRevisionPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionPatchType] { + return pulumix.Output[ControllerRevisionPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -375,6 +424,12 @@ func (i DaemonSetTypeArgs) ToDaemonSetTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetTypeOutput) } +func (i DaemonSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetType] { + return pulumix.Output[DaemonSetType]{ + OutputState: i.ToDaemonSetTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSetTypeArrayInput is an input type that accepts DaemonSetTypeArray and DaemonSetTypeArrayOutput values. // You can construct a concrete instance of `DaemonSetTypeArrayInput` via: // @@ -400,6 +455,12 @@ func (i DaemonSetTypeArray) ToDaemonSetTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetTypeArrayOutput) } +func (i DaemonSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetType] { + return pulumix.Output[[]DaemonSetType]{ + OutputState: i.ToDaemonSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSet represents the configuration of a daemon set. type DaemonSetTypeOutput struct{ *pulumi.OutputState } @@ -415,6 +476,12 @@ func (o DaemonSetTypeOutput) ToDaemonSetTypeOutputWithContext(ctx context.Contex return o } +func (o DaemonSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetType] { + return pulumix.Output[DaemonSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -454,6 +521,12 @@ func (o DaemonSetTypeArrayOutput) ToDaemonSetTypeArrayOutputWithContext(ctx cont return o } +func (o DaemonSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetType] { + return pulumix.Output[[]DaemonSetType]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetTypeArrayOutput) Index(i pulumi.IntInput) DaemonSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetType { return vs[0].([]DaemonSetType)[vs[1].(int)] @@ -511,6 +584,12 @@ func (i DaemonSetConditionArgs) ToDaemonSetConditionOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionOutput) } +func (i DaemonSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetCondition] { + return pulumix.Output[DaemonSetCondition]{ + OutputState: i.ToDaemonSetConditionOutputWithContext(ctx).OutputState, + } +} + // DaemonSetConditionArrayInput is an input type that accepts DaemonSetConditionArray and DaemonSetConditionArrayOutput values. // You can construct a concrete instance of `DaemonSetConditionArrayInput` via: // @@ -536,6 +615,12 @@ func (i DaemonSetConditionArray) ToDaemonSetConditionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionArrayOutput) } +func (i DaemonSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetCondition] { + return pulumix.Output[[]DaemonSetCondition]{ + OutputState: i.ToDaemonSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetCondition describes the state of a DaemonSet at a certain point. type DaemonSetConditionOutput struct{ *pulumi.OutputState } @@ -551,6 +636,12 @@ func (o DaemonSetConditionOutput) ToDaemonSetConditionOutputWithContext(ctx cont return o } +func (o DaemonSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetCondition] { + return pulumix.Output[DaemonSetCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DaemonSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -590,6 +681,12 @@ func (o DaemonSetConditionArrayOutput) ToDaemonSetConditionArrayOutputWithContex return o } +func (o DaemonSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetCondition] { + return pulumix.Output[[]DaemonSetCondition]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetConditionArrayOutput) Index(i pulumi.IntInput) DaemonSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetCondition { return vs[0].([]DaemonSetCondition)[vs[1].(int)] @@ -647,6 +744,12 @@ func (i DaemonSetConditionPatchArgs) ToDaemonSetConditionPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionPatchOutput) } +func (i DaemonSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetConditionPatch] { + return pulumix.Output[DaemonSetConditionPatch]{ + OutputState: i.ToDaemonSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DaemonSetConditionPatchArrayInput is an input type that accepts DaemonSetConditionPatchArray and DaemonSetConditionPatchArrayOutput values. // You can construct a concrete instance of `DaemonSetConditionPatchArrayInput` via: // @@ -672,6 +775,12 @@ func (i DaemonSetConditionPatchArray) ToDaemonSetConditionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionPatchArrayOutput) } +func (i DaemonSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetConditionPatch] { + return pulumix.Output[[]DaemonSetConditionPatch]{ + OutputState: i.ToDaemonSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetCondition describes the state of a DaemonSet at a certain point. type DaemonSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -687,6 +796,12 @@ func (o DaemonSetConditionPatchOutput) ToDaemonSetConditionPatchOutputWithContex return o } +func (o DaemonSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetConditionPatch] { + return pulumix.Output[DaemonSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DaemonSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -726,6 +841,12 @@ func (o DaemonSetConditionPatchArrayOutput) ToDaemonSetConditionPatchArrayOutput return o } +func (o DaemonSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetConditionPatch] { + return pulumix.Output[[]DaemonSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetConditionPatchArrayOutput) Index(i pulumi.IntInput) DaemonSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetConditionPatch { return vs[0].([]DaemonSetConditionPatch)[vs[1].(int)] @@ -779,6 +900,12 @@ func (i DaemonSetListTypeArgs) ToDaemonSetListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListTypeOutput) } +func (i DaemonSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetListType] { + return pulumix.Output[DaemonSetListType]{ + OutputState: i.ToDaemonSetListTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSetList is a collection of daemon sets. type DaemonSetListTypeOutput struct{ *pulumi.OutputState } @@ -794,6 +921,12 @@ func (o DaemonSetListTypeOutput) ToDaemonSetListTypeOutputWithContext(ctx contex return o } +func (o DaemonSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetListType] { + return pulumix.Output[DaemonSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -865,6 +998,12 @@ func (i DaemonSetPatchTypeArgs) ToDaemonSetPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchTypeOutput) } +func (i DaemonSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetPatchType] { + return pulumix.Output[DaemonSetPatchType]{ + OutputState: i.ToDaemonSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSet represents the configuration of a daemon set. type DaemonSetPatchTypeOutput struct{ *pulumi.OutputState } @@ -880,6 +1019,12 @@ func (o DaemonSetPatchTypeOutput) ToDaemonSetPatchTypeOutputWithContext(ctx cont return o } +func (o DaemonSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetPatchType] { + return pulumix.Output[DaemonSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -956,6 +1101,12 @@ func (i DaemonSetSpecArgs) ToDaemonSetSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecOutput) } +func (i DaemonSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpec] { + return pulumix.Output[DaemonSetSpec]{ + OutputState: i.ToDaemonSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetSpecArgs) ToDaemonSetSpecPtrOutput() DaemonSetSpecPtrOutput { return i.ToDaemonSetSpecPtrOutputWithContext(context.Background()) } @@ -997,6 +1148,12 @@ func (i *daemonSetSpecPtrType) ToDaemonSetSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPtrOutput) } +func (i *daemonSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpec] { + return pulumix.Output[*DaemonSetSpec]{ + OutputState: i.ToDaemonSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetSpec is the specification of a daemon set. type DaemonSetSpecOutput struct{ *pulumi.OutputState } @@ -1022,6 +1179,12 @@ func (o DaemonSetSpecOutput) ToDaemonSetSpecPtrOutputWithContext(ctx context.Con }).(DaemonSetSpecPtrOutput) } +func (o DaemonSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpec] { + return pulumix.Output[DaemonSetSpec]{ + OutputState: o.OutputState, + } +} + // The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). func (o DaemonSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1061,6 +1224,12 @@ func (o DaemonSetSpecPtrOutput) ToDaemonSetSpecPtrOutputWithContext(ctx context. return o } +func (o DaemonSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpec] { + return pulumix.Output[*DaemonSetSpec]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetSpecPtrOutput) Elem() DaemonSetSpecOutput { return o.ApplyT(func(v *DaemonSetSpec) DaemonSetSpec { if v != nil { @@ -1172,6 +1341,12 @@ func (i DaemonSetSpecPatchArgs) ToDaemonSetSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPatchOutput) } +func (i DaemonSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpecPatch] { + return pulumix.Output[DaemonSetSpecPatch]{ + OutputState: i.ToDaemonSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetSpecPatchArgs) ToDaemonSetSpecPatchPtrOutput() DaemonSetSpecPatchPtrOutput { return i.ToDaemonSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -1213,6 +1388,12 @@ func (i *daemonSetSpecPatchPtrType) ToDaemonSetSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPatchPtrOutput) } +func (i *daemonSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpecPatch] { + return pulumix.Output[*DaemonSetSpecPatch]{ + OutputState: i.ToDaemonSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetSpec is the specification of a daemon set. type DaemonSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -1238,6 +1419,12 @@ func (o DaemonSetSpecPatchOutput) ToDaemonSetSpecPatchPtrOutputWithContext(ctx c }).(DaemonSetSpecPatchPtrOutput) } +func (o DaemonSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpecPatch] { + return pulumix.Output[DaemonSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). func (o DaemonSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1277,6 +1464,12 @@ func (o DaemonSetSpecPatchPtrOutput) ToDaemonSetSpecPatchPtrOutputWithContext(ct return o } +func (o DaemonSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpecPatch] { + return pulumix.Output[*DaemonSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetSpecPatchPtrOutput) Elem() DaemonSetSpecPatchOutput { return o.ApplyT(func(v *DaemonSetSpecPatch) DaemonSetSpecPatch { if v != nil { @@ -1408,6 +1601,12 @@ func (i DaemonSetStatusArgs) ToDaemonSetStatusOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusOutput) } +func (i DaemonSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatus] { + return pulumix.Output[DaemonSetStatus]{ + OutputState: i.ToDaemonSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetStatusArgs) ToDaemonSetStatusPtrOutput() DaemonSetStatusPtrOutput { return i.ToDaemonSetStatusPtrOutputWithContext(context.Background()) } @@ -1449,6 +1648,12 @@ func (i *daemonSetStatusPtrType) ToDaemonSetStatusPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPtrOutput) } +func (i *daemonSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatus] { + return pulumix.Output[*DaemonSetStatus]{ + OutputState: i.ToDaemonSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetStatus represents the current status of a daemon set. type DaemonSetStatusOutput struct{ *pulumi.OutputState } @@ -1474,6 +1679,12 @@ func (o DaemonSetStatusOutput) ToDaemonSetStatusPtrOutputWithContext(ctx context }).(DaemonSetStatusPtrOutput) } +func (o DaemonSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatus] { + return pulumix.Output[DaemonSetStatus]{ + OutputState: o.OutputState, + } +} + // Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o DaemonSetStatusOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetStatus) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -1538,6 +1749,12 @@ func (o DaemonSetStatusPtrOutput) ToDaemonSetStatusPtrOutputWithContext(ctx cont return o } +func (o DaemonSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatus] { + return pulumix.Output[*DaemonSetStatus]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetStatusPtrOutput) Elem() DaemonSetStatusOutput { return o.ApplyT(func(v *DaemonSetStatus) DaemonSetStatus { if v != nil { @@ -1719,6 +1936,12 @@ func (i DaemonSetStatusPatchArgs) ToDaemonSetStatusPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPatchOutput) } +func (i DaemonSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatusPatch] { + return pulumix.Output[DaemonSetStatusPatch]{ + OutputState: i.ToDaemonSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetStatusPatchArgs) ToDaemonSetStatusPatchPtrOutput() DaemonSetStatusPatchPtrOutput { return i.ToDaemonSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -1760,6 +1983,12 @@ func (i *daemonSetStatusPatchPtrType) ToDaemonSetStatusPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPatchPtrOutput) } +func (i *daemonSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatusPatch] { + return pulumix.Output[*DaemonSetStatusPatch]{ + OutputState: i.ToDaemonSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetStatus represents the current status of a daemon set. type DaemonSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -1785,6 +2014,12 @@ func (o DaemonSetStatusPatchOutput) ToDaemonSetStatusPatchPtrOutputWithContext(c }).(DaemonSetStatusPatchPtrOutput) } +func (o DaemonSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatusPatch] { + return pulumix.Output[DaemonSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o DaemonSetStatusPatchOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetStatusPatch) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -1849,6 +2084,12 @@ func (o DaemonSetStatusPatchPtrOutput) ToDaemonSetStatusPatchPtrOutputWithContex return o } +func (o DaemonSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatusPatch] { + return pulumix.Output[*DaemonSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetStatusPatchPtrOutput) Elem() DaemonSetStatusPatchOutput { return o.ApplyT(func(v *DaemonSetStatusPatch) DaemonSetStatusPatch { if v != nil { @@ -1998,6 +2239,12 @@ func (i DaemonSetUpdateStrategyArgs) ToDaemonSetUpdateStrategyOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyOutput) } +func (i DaemonSetUpdateStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategy] { + return pulumix.Output[DaemonSetUpdateStrategy]{ + OutputState: i.ToDaemonSetUpdateStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetUpdateStrategyArgs) ToDaemonSetUpdateStrategyPtrOutput() DaemonSetUpdateStrategyPtrOutput { return i.ToDaemonSetUpdateStrategyPtrOutputWithContext(context.Background()) } @@ -2039,6 +2286,12 @@ func (i *daemonSetUpdateStrategyPtrType) ToDaemonSetUpdateStrategyPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPtrOutput) } +func (i *daemonSetUpdateStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategy] { + return pulumix.Output[*DaemonSetUpdateStrategy]{ + OutputState: i.ToDaemonSetUpdateStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. type DaemonSetUpdateStrategyOutput struct{ *pulumi.OutputState } @@ -2064,6 +2317,12 @@ func (o DaemonSetUpdateStrategyOutput) ToDaemonSetUpdateStrategyPtrOutputWithCon }).(DaemonSetUpdateStrategyPtrOutput) } +func (o DaemonSetUpdateStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategy] { + return pulumix.Output[DaemonSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if type = "RollingUpdate". func (o DaemonSetUpdateStrategyOutput) RollingUpdate() RollingUpdateDaemonSetPtrOutput { return o.ApplyT(func(v DaemonSetUpdateStrategy) *RollingUpdateDaemonSet { return v.RollingUpdate }).(RollingUpdateDaemonSetPtrOutput) @@ -2088,6 +2347,12 @@ func (o DaemonSetUpdateStrategyPtrOutput) ToDaemonSetUpdateStrategyPtrOutputWith return o } +func (o DaemonSetUpdateStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategy] { + return pulumix.Output[*DaemonSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetUpdateStrategyPtrOutput) Elem() DaemonSetUpdateStrategyOutput { return o.ApplyT(func(v *DaemonSetUpdateStrategy) DaemonSetUpdateStrategy { if v != nil { @@ -2157,6 +2422,12 @@ func (i DaemonSetUpdateStrategyPatchArgs) ToDaemonSetUpdateStrategyPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPatchOutput) } +func (i DaemonSetUpdateStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategyPatch] { + return pulumix.Output[DaemonSetUpdateStrategyPatch]{ + OutputState: i.ToDaemonSetUpdateStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetUpdateStrategyPatchArgs) ToDaemonSetUpdateStrategyPatchPtrOutput() DaemonSetUpdateStrategyPatchPtrOutput { return i.ToDaemonSetUpdateStrategyPatchPtrOutputWithContext(context.Background()) } @@ -2198,6 +2469,12 @@ func (i *daemonSetUpdateStrategyPatchPtrType) ToDaemonSetUpdateStrategyPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPatchPtrOutput) } +func (i *daemonSetUpdateStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategyPatch] { + return pulumix.Output[*DaemonSetUpdateStrategyPatch]{ + OutputState: i.ToDaemonSetUpdateStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. type DaemonSetUpdateStrategyPatchOutput struct{ *pulumi.OutputState } @@ -2223,6 +2500,12 @@ func (o DaemonSetUpdateStrategyPatchOutput) ToDaemonSetUpdateStrategyPatchPtrOut }).(DaemonSetUpdateStrategyPatchPtrOutput) } +func (o DaemonSetUpdateStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategyPatch] { + return pulumix.Output[DaemonSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if type = "RollingUpdate". func (o DaemonSetUpdateStrategyPatchOutput) RollingUpdate() RollingUpdateDaemonSetPatchPtrOutput { return o.ApplyT(func(v DaemonSetUpdateStrategyPatch) *RollingUpdateDaemonSetPatch { return v.RollingUpdate }).(RollingUpdateDaemonSetPatchPtrOutput) @@ -2247,6 +2530,12 @@ func (o DaemonSetUpdateStrategyPatchPtrOutput) ToDaemonSetUpdateStrategyPatchPtr return o } +func (o DaemonSetUpdateStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategyPatch] { + return pulumix.Output[*DaemonSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetUpdateStrategyPatchPtrOutput) Elem() DaemonSetUpdateStrategyPatchOutput { return o.ApplyT(func(v *DaemonSetUpdateStrategyPatch) DaemonSetUpdateStrategyPatch { if v != nil { @@ -2372,6 +2661,12 @@ func (i DeploymentTypeArgs) ToDeploymentTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeOutput) } +func (i DeploymentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: i.ToDeploymentTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentTypeArrayInput is an input type that accepts DeploymentTypeArray and DeploymentTypeArrayOutput values. // You can construct a concrete instance of `DeploymentTypeArrayInput` via: // @@ -2397,6 +2692,12 @@ func (i DeploymentTypeArray) ToDeploymentTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeArrayOutput) } +func (i DeploymentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: i.ToDeploymentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -2434,6 +2735,12 @@ func (o DeploymentTypeOutput) ToDeploymentTypeOutputWithContext(ctx context.Cont return o } +func (o DeploymentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2473,6 +2780,12 @@ func (o DeploymentTypeArrayOutput) ToDeploymentTypeArrayOutputWithContext(ctx co return o } +func (o DeploymentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: o.OutputState, + } +} + func (o DeploymentTypeArrayOutput) Index(i pulumi.IntInput) DeploymentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentType { return vs[0].([]DeploymentType)[vs[1].(int)] @@ -2534,6 +2847,12 @@ func (i DeploymentConditionArgs) ToDeploymentConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionOutput) } +func (i DeploymentConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: i.ToDeploymentConditionOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionArrayInput is an input type that accepts DeploymentConditionArray and DeploymentConditionArrayOutput values. // You can construct a concrete instance of `DeploymentConditionArrayInput` via: // @@ -2559,6 +2878,12 @@ func (i DeploymentConditionArray) ToDeploymentConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionArrayOutput) } +func (i DeploymentConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: i.ToDeploymentConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionOutput struct{ *pulumi.OutputState } @@ -2574,6 +2899,12 @@ func (o DeploymentConditionOutput) ToDeploymentConditionOutputWithContext(ctx co return o } +func (o DeploymentConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2618,6 +2949,12 @@ func (o DeploymentConditionArrayOutput) ToDeploymentConditionArrayOutputWithCont return o } +func (o DeploymentConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionArrayOutput) Index(i pulumi.IntInput) DeploymentConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentCondition { return vs[0].([]DeploymentCondition)[vs[1].(int)] @@ -2679,6 +3016,12 @@ func (i DeploymentConditionPatchArgs) ToDeploymentConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchOutput) } +func (i DeploymentConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionPatchArrayInput is an input type that accepts DeploymentConditionPatchArray and DeploymentConditionPatchArrayOutput values. // You can construct a concrete instance of `DeploymentConditionPatchArrayInput` via: // @@ -2704,6 +3047,12 @@ func (i DeploymentConditionPatchArray) ToDeploymentConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchArrayOutput) } +func (i DeploymentConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionPatchOutput struct{ *pulumi.OutputState } @@ -2719,6 +3068,12 @@ func (o DeploymentConditionPatchOutput) ToDeploymentConditionPatchOutputWithCont return o } +func (o DeploymentConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2763,6 +3118,12 @@ func (o DeploymentConditionPatchArrayOutput) ToDeploymentConditionPatchArrayOutp return o } +func (o DeploymentConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionPatchArrayOutput) Index(i pulumi.IntInput) DeploymentConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentConditionPatch { return vs[0].([]DeploymentConditionPatch)[vs[1].(int)] @@ -2816,6 +3177,12 @@ func (i DeploymentListTypeArgs) ToDeploymentListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentListTypeOutput) } +func (i DeploymentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: i.ToDeploymentListTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentList is a list of Deployments. type DeploymentListTypeOutput struct{ *pulumi.OutputState } @@ -2831,6 +3198,12 @@ func (o DeploymentListTypeOutput) ToDeploymentListTypeOutputWithContext(ctx cont return o } +func (o DeploymentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2946,6 +3319,12 @@ func (i DeploymentPatchTypeArgs) ToDeploymentPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchTypeOutput) } +func (i DeploymentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: i.ToDeploymentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -2983,6 +3362,12 @@ func (o DeploymentPatchTypeOutput) ToDeploymentPatchTypeOutputWithContext(ctx co return o } +func (o DeploymentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3071,6 +3456,12 @@ func (i DeploymentSpecArgs) ToDeploymentSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecOutput) } +func (i DeploymentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: i.ToDeploymentSpecOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecArgs) ToDeploymentSpecPtrOutput() DeploymentSpecPtrOutput { return i.ToDeploymentSpecPtrOutputWithContext(context.Background()) } @@ -3112,6 +3503,12 @@ func (i *deploymentSpecPtrType) ToDeploymentSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPtrOutput) } +func (i *deploymentSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: i.ToDeploymentSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecOutput struct{ *pulumi.OutputState } @@ -3137,6 +3534,12 @@ func (o DeploymentSpecOutput) ToDeploymentSpecPtrOutputWithContext(ctx context.C }).(DeploymentSpecPtrOutput) } +func (o DeploymentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -3191,6 +3594,12 @@ func (o DeploymentSpecPtrOutput) ToDeploymentSpecPtrOutputWithContext(ctx contex return o } +func (o DeploymentSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPtrOutput) Elem() DeploymentSpecOutput { return o.ApplyT(func(v *DeploymentSpec) DeploymentSpec { if v != nil { @@ -3344,6 +3753,12 @@ func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchOutput) } +func (i DeploymentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchPtrOutput() DeploymentSpecPatchPtrOutput { return i.ToDeploymentSpecPatchPtrOutputWithContext(context.Background()) } @@ -3385,6 +3800,12 @@ func (i *deploymentSpecPatchPtrType) ToDeploymentSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchPtrOutput) } +func (i *deploymentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecPatchOutput struct{ *pulumi.OutputState } @@ -3410,6 +3831,12 @@ func (o DeploymentSpecPatchOutput) ToDeploymentSpecPatchPtrOutputWithContext(ctx }).(DeploymentSpecPatchPtrOutput) } +func (o DeploymentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -3464,6 +3891,12 @@ func (o DeploymentSpecPatchPtrOutput) ToDeploymentSpecPatchPtrOutputWithContext( return o } +func (o DeploymentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPatchPtrOutput) Elem() DeploymentSpecPatchOutput { return o.ApplyT(func(v *DeploymentSpecPatch) DeploymentSpecPatch { if v != nil { @@ -3617,6 +4050,12 @@ func (i DeploymentStatusArgs) ToDeploymentStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusOutput) } +func (i DeploymentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: i.ToDeploymentStatusOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusArgs) ToDeploymentStatusPtrOutput() DeploymentStatusPtrOutput { return i.ToDeploymentStatusPtrOutputWithContext(context.Background()) } @@ -3658,6 +4097,12 @@ func (i *deploymentStatusPtrType) ToDeploymentStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPtrOutput) } +func (i *deploymentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: i.ToDeploymentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusOutput struct{ *pulumi.OutputState } @@ -3683,6 +4128,12 @@ func (o DeploymentStatusOutput) ToDeploymentStatusPtrOutputWithContext(ctx conte }).(DeploymentStatusPtrOutput) } +func (o DeploymentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -3737,6 +4188,12 @@ func (o DeploymentStatusPtrOutput) ToDeploymentStatusPtrOutputWithContext(ctx co return o } +func (o DeploymentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPtrOutput) Elem() DeploymentStatusOutput { return o.ApplyT(func(v *DeploymentStatus) DeploymentStatus { if v != nil { @@ -3890,6 +4347,12 @@ func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchOutput) } +func (i DeploymentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchPtrOutput() DeploymentStatusPatchPtrOutput { return i.ToDeploymentStatusPatchPtrOutputWithContext(context.Background()) } @@ -3931,6 +4394,12 @@ func (i *deploymentStatusPatchPtrType) ToDeploymentStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchPtrOutput) } +func (i *deploymentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusPatchOutput struct{ *pulumi.OutputState } @@ -3956,6 +4425,12 @@ func (o DeploymentStatusPatchOutput) ToDeploymentStatusPatchPtrOutputWithContext }).(DeploymentStatusPatchPtrOutput) } +func (o DeploymentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -4010,6 +4485,12 @@ func (o DeploymentStatusPatchPtrOutput) ToDeploymentStatusPatchPtrOutputWithCont return o } +func (o DeploymentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPatchPtrOutput) Elem() DeploymentStatusPatchOutput { return o.ApplyT(func(v *DeploymentStatusPatch) DeploymentStatusPatch { if v != nil { @@ -4139,6 +4620,12 @@ func (i DeploymentStrategyArgs) ToDeploymentStrategyOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyOutput) } +func (i DeploymentStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyArgs) ToDeploymentStrategyPtrOutput() DeploymentStrategyPtrOutput { return i.ToDeploymentStrategyPtrOutputWithContext(context.Background()) } @@ -4180,6 +4667,12 @@ func (i *deploymentStrategyPtrType) ToDeploymentStrategyPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPtrOutput) } +func (i *deploymentStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyOutput struct{ *pulumi.OutputState } @@ -4205,6 +4698,12 @@ func (o DeploymentStrategyOutput) ToDeploymentStrategyPtrOutputWithContext(ctx c }).(DeploymentStrategyPtrOutput) } +func (o DeploymentStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyOutput) RollingUpdate() RollingUpdateDeploymentPtrOutput { return o.ApplyT(func(v DeploymentStrategy) *RollingUpdateDeployment { return v.RollingUpdate }).(RollingUpdateDeploymentPtrOutput) @@ -4229,6 +4728,12 @@ func (o DeploymentStrategyPtrOutput) ToDeploymentStrategyPtrOutputWithContext(ct return o } +func (o DeploymentStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPtrOutput) Elem() DeploymentStrategyOutput { return o.ApplyT(func(v *DeploymentStrategy) DeploymentStrategy { if v != nil { @@ -4298,6 +4803,12 @@ func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchOutput) } +func (i DeploymentStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchPtrOutput() DeploymentStrategyPatchPtrOutput { return i.ToDeploymentStrategyPatchPtrOutputWithContext(context.Background()) } @@ -4339,6 +4850,12 @@ func (i *deploymentStrategyPatchPtrType) ToDeploymentStrategyPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchPtrOutput) } +func (i *deploymentStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyPatchOutput struct{ *pulumi.OutputState } @@ -4364,6 +4881,12 @@ func (o DeploymentStrategyPatchOutput) ToDeploymentStrategyPatchPtrOutputWithCon }).(DeploymentStrategyPatchPtrOutput) } +func (o DeploymentStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyPatchOutput) RollingUpdate() RollingUpdateDeploymentPatchPtrOutput { return o.ApplyT(func(v DeploymentStrategyPatch) *RollingUpdateDeploymentPatch { return v.RollingUpdate }).(RollingUpdateDeploymentPatchPtrOutput) @@ -4388,6 +4911,12 @@ func (o DeploymentStrategyPatchPtrOutput) ToDeploymentStrategyPatchPtrOutputWith return o } +func (o DeploymentStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPatchPtrOutput) Elem() DeploymentStrategyPatchOutput { return o.ApplyT(func(v *DeploymentStrategyPatch) DeploymentStrategyPatch { if v != nil { @@ -4469,6 +4998,12 @@ func (i ReplicaSetTypeArgs) ToReplicaSetTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetTypeOutput) } +func (i ReplicaSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetType] { + return pulumix.Output[ReplicaSetType]{ + OutputState: i.ToReplicaSetTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetTypeArrayInput is an input type that accepts ReplicaSetTypeArray and ReplicaSetTypeArrayOutput values. // You can construct a concrete instance of `ReplicaSetTypeArrayInput` via: // @@ -4494,6 +5029,12 @@ func (i ReplicaSetTypeArray) ToReplicaSetTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetTypeArrayOutput) } +func (i ReplicaSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetType] { + return pulumix.Output[[]ReplicaSetType]{ + OutputState: i.ToReplicaSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSet ensures that a specified number of pod replicas are running at any given time. type ReplicaSetTypeOutput struct{ *pulumi.OutputState } @@ -4509,6 +5050,12 @@ func (o ReplicaSetTypeOutput) ToReplicaSetTypeOutputWithContext(ctx context.Cont return o } +func (o ReplicaSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetType] { + return pulumix.Output[ReplicaSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4548,6 +5095,12 @@ func (o ReplicaSetTypeArrayOutput) ToReplicaSetTypeArrayOutputWithContext(ctx co return o } +func (o ReplicaSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetType] { + return pulumix.Output[[]ReplicaSetType]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetTypeArrayOutput) Index(i pulumi.IntInput) ReplicaSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetType { return vs[0].([]ReplicaSetType)[vs[1].(int)] @@ -4605,6 +5158,12 @@ func (i ReplicaSetConditionArgs) ToReplicaSetConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionOutput) } +func (i ReplicaSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetCondition] { + return pulumix.Output[ReplicaSetCondition]{ + OutputState: i.ToReplicaSetConditionOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetConditionArrayInput is an input type that accepts ReplicaSetConditionArray and ReplicaSetConditionArrayOutput values. // You can construct a concrete instance of `ReplicaSetConditionArrayInput` via: // @@ -4630,6 +5189,12 @@ func (i ReplicaSetConditionArray) ToReplicaSetConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionArrayOutput) } +func (i ReplicaSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetCondition] { + return pulumix.Output[[]ReplicaSetCondition]{ + OutputState: i.ToReplicaSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetCondition describes the state of a replica set at a certain point. type ReplicaSetConditionOutput struct{ *pulumi.OutputState } @@ -4645,6 +5210,12 @@ func (o ReplicaSetConditionOutput) ToReplicaSetConditionOutputWithContext(ctx co return o } +func (o ReplicaSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetCondition] { + return pulumix.Output[ReplicaSetCondition]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicaSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -4684,6 +5255,12 @@ func (o ReplicaSetConditionArrayOutput) ToReplicaSetConditionArrayOutputWithCont return o } +func (o ReplicaSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetCondition] { + return pulumix.Output[[]ReplicaSetCondition]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetConditionArrayOutput) Index(i pulumi.IntInput) ReplicaSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetCondition { return vs[0].([]ReplicaSetCondition)[vs[1].(int)] @@ -4741,6 +5318,12 @@ func (i ReplicaSetConditionPatchArgs) ToReplicaSetConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionPatchOutput) } +func (i ReplicaSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetConditionPatch] { + return pulumix.Output[ReplicaSetConditionPatch]{ + OutputState: i.ToReplicaSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetConditionPatchArrayInput is an input type that accepts ReplicaSetConditionPatchArray and ReplicaSetConditionPatchArrayOutput values. // You can construct a concrete instance of `ReplicaSetConditionPatchArrayInput` via: // @@ -4766,6 +5349,12 @@ func (i ReplicaSetConditionPatchArray) ToReplicaSetConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionPatchArrayOutput) } +func (i ReplicaSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetConditionPatch] { + return pulumix.Output[[]ReplicaSetConditionPatch]{ + OutputState: i.ToReplicaSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetCondition describes the state of a replica set at a certain point. type ReplicaSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -4781,6 +5370,12 @@ func (o ReplicaSetConditionPatchOutput) ToReplicaSetConditionPatchOutputWithCont return o } +func (o ReplicaSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetConditionPatch] { + return pulumix.Output[ReplicaSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicaSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -4820,6 +5415,12 @@ func (o ReplicaSetConditionPatchArrayOutput) ToReplicaSetConditionPatchArrayOutp return o } +func (o ReplicaSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetConditionPatch] { + return pulumix.Output[[]ReplicaSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetConditionPatchArrayOutput) Index(i pulumi.IntInput) ReplicaSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetConditionPatch { return vs[0].([]ReplicaSetConditionPatch)[vs[1].(int)] @@ -4873,6 +5474,12 @@ func (i ReplicaSetListTypeArgs) ToReplicaSetListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListTypeOutput) } +func (i ReplicaSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetListType] { + return pulumix.Output[ReplicaSetListType]{ + OutputState: i.ToReplicaSetListTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetList is a collection of ReplicaSets. type ReplicaSetListTypeOutput struct{ *pulumi.OutputState } @@ -4888,6 +5495,12 @@ func (o ReplicaSetListTypeOutput) ToReplicaSetListTypeOutputWithContext(ctx cont return o } +func (o ReplicaSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetListType] { + return pulumix.Output[ReplicaSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4959,6 +5572,12 @@ func (i ReplicaSetPatchTypeArgs) ToReplicaSetPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchTypeOutput) } +func (i ReplicaSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetPatchType] { + return pulumix.Output[ReplicaSetPatchType]{ + OutputState: i.ToReplicaSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSet ensures that a specified number of pod replicas are running at any given time. type ReplicaSetPatchTypeOutput struct{ *pulumi.OutputState } @@ -4974,6 +5593,12 @@ func (o ReplicaSetPatchTypeOutput) ToReplicaSetPatchTypeOutputWithContext(ctx co return o } +func (o ReplicaSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetPatchType] { + return pulumix.Output[ReplicaSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5046,6 +5671,12 @@ func (i ReplicaSetSpecArgs) ToReplicaSetSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecOutput) } +func (i ReplicaSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpec] { + return pulumix.Output[ReplicaSetSpec]{ + OutputState: i.ToReplicaSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetSpecArgs) ToReplicaSetSpecPtrOutput() ReplicaSetSpecPtrOutput { return i.ToReplicaSetSpecPtrOutputWithContext(context.Background()) } @@ -5087,6 +5718,12 @@ func (i *replicaSetSpecPtrType) ToReplicaSetSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPtrOutput) } +func (i *replicaSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpec] { + return pulumix.Output[*ReplicaSetSpec]{ + OutputState: i.ToReplicaSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetSpec is the specification of a ReplicaSet. type ReplicaSetSpecOutput struct{ *pulumi.OutputState } @@ -5112,6 +5749,12 @@ func (o ReplicaSetSpecOutput) ToReplicaSetSpecPtrOutputWithContext(ctx context.C }).(ReplicaSetSpecPtrOutput) } +func (o ReplicaSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpec] { + return pulumix.Output[ReplicaSetSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicaSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -5146,6 +5789,12 @@ func (o ReplicaSetSpecPtrOutput) ToReplicaSetSpecPtrOutputWithContext(ctx contex return o } +func (o ReplicaSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpec] { + return pulumix.Output[*ReplicaSetSpec]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetSpecPtrOutput) Elem() ReplicaSetSpecOutput { return o.ApplyT(func(v *ReplicaSetSpec) ReplicaSetSpec { if v != nil { @@ -5243,6 +5892,12 @@ func (i ReplicaSetSpecPatchArgs) ToReplicaSetSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPatchOutput) } +func (i ReplicaSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpecPatch] { + return pulumix.Output[ReplicaSetSpecPatch]{ + OutputState: i.ToReplicaSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetSpecPatchArgs) ToReplicaSetSpecPatchPtrOutput() ReplicaSetSpecPatchPtrOutput { return i.ToReplicaSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -5284,6 +5939,12 @@ func (i *replicaSetSpecPatchPtrType) ToReplicaSetSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPatchPtrOutput) } +func (i *replicaSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpecPatch] { + return pulumix.Output[*ReplicaSetSpecPatch]{ + OutputState: i.ToReplicaSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetSpec is the specification of a ReplicaSet. type ReplicaSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -5309,6 +5970,12 @@ func (o ReplicaSetSpecPatchOutput) ToReplicaSetSpecPatchPtrOutputWithContext(ctx }).(ReplicaSetSpecPatchPtrOutput) } +func (o ReplicaSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpecPatch] { + return pulumix.Output[ReplicaSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicaSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -5343,6 +6010,12 @@ func (o ReplicaSetSpecPatchPtrOutput) ToReplicaSetSpecPatchPtrOutputWithContext( return o } +func (o ReplicaSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpecPatch] { + return pulumix.Output[*ReplicaSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetSpecPatchPtrOutput) Elem() ReplicaSetSpecPatchOutput { return o.ApplyT(func(v *ReplicaSetSpecPatch) ReplicaSetSpecPatch { if v != nil { @@ -5448,6 +6121,12 @@ func (i ReplicaSetStatusArgs) ToReplicaSetStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusOutput) } +func (i ReplicaSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatus] { + return pulumix.Output[ReplicaSetStatus]{ + OutputState: i.ToReplicaSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetStatusArgs) ToReplicaSetStatusPtrOutput() ReplicaSetStatusPtrOutput { return i.ToReplicaSetStatusPtrOutputWithContext(context.Background()) } @@ -5489,6 +6168,12 @@ func (i *replicaSetStatusPtrType) ToReplicaSetStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPtrOutput) } +func (i *replicaSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatus] { + return pulumix.Output[*ReplicaSetStatus]{ + OutputState: i.ToReplicaSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetStatus represents the current status of a ReplicaSet. type ReplicaSetStatusOutput struct{ *pulumi.OutputState } @@ -5514,6 +6199,12 @@ func (o ReplicaSetStatusOutput) ToReplicaSetStatusPtrOutputWithContext(ctx conte }).(ReplicaSetStatusPtrOutput) } +func (o ReplicaSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatus] { + return pulumix.Output[ReplicaSetStatus]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replica set. func (o ReplicaSetStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -5558,6 +6249,12 @@ func (o ReplicaSetStatusPtrOutput) ToReplicaSetStatusPtrOutputWithContext(ctx co return o } +func (o ReplicaSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatus] { + return pulumix.Output[*ReplicaSetStatus]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetStatusPtrOutput) Elem() ReplicaSetStatusOutput { return o.ApplyT(func(v *ReplicaSetStatus) ReplicaSetStatus { if v != nil { @@ -5683,6 +6380,12 @@ func (i ReplicaSetStatusPatchArgs) ToReplicaSetStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPatchOutput) } +func (i ReplicaSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatusPatch] { + return pulumix.Output[ReplicaSetStatusPatch]{ + OutputState: i.ToReplicaSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetStatusPatchArgs) ToReplicaSetStatusPatchPtrOutput() ReplicaSetStatusPatchPtrOutput { return i.ToReplicaSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -5724,6 +6427,12 @@ func (i *replicaSetStatusPatchPtrType) ToReplicaSetStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPatchPtrOutput) } +func (i *replicaSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatusPatch] { + return pulumix.Output[*ReplicaSetStatusPatch]{ + OutputState: i.ToReplicaSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetStatus represents the current status of a ReplicaSet. type ReplicaSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -5749,6 +6458,12 @@ func (o ReplicaSetStatusPatchOutput) ToReplicaSetStatusPatchPtrOutputWithContext }).(ReplicaSetStatusPatchPtrOutput) } +func (o ReplicaSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatusPatch] { + return pulumix.Output[ReplicaSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replica set. func (o ReplicaSetStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -5793,6 +6508,12 @@ func (o ReplicaSetStatusPatchPtrOutput) ToReplicaSetStatusPatchPtrOutputWithCont return o } +func (o ReplicaSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatusPatch] { + return pulumix.Output[*ReplicaSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetStatusPatchPtrOutput) Elem() ReplicaSetStatusPatchOutput { return o.ApplyT(func(v *ReplicaSetStatusPatch) ReplicaSetStatusPatch { if v != nil { @@ -5902,6 +6623,12 @@ func (i RollingUpdateDaemonSetArgs) ToRollingUpdateDaemonSetOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetOutput) } +func (i RollingUpdateDaemonSetArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSet] { + return pulumix.Output[RollingUpdateDaemonSet]{ + OutputState: i.ToRollingUpdateDaemonSetOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDaemonSetArgs) ToRollingUpdateDaemonSetPtrOutput() RollingUpdateDaemonSetPtrOutput { return i.ToRollingUpdateDaemonSetPtrOutputWithContext(context.Background()) } @@ -5943,6 +6670,12 @@ func (i *rollingUpdateDaemonSetPtrType) ToRollingUpdateDaemonSetPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPtrOutput) } +func (i *rollingUpdateDaemonSetPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSet] { + return pulumix.Output[*RollingUpdateDaemonSet]{ + OutputState: i.ToRollingUpdateDaemonSetPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of daemon set rolling update. type RollingUpdateDaemonSetOutput struct{ *pulumi.OutputState } @@ -5968,6 +6701,12 @@ func (o RollingUpdateDaemonSetOutput) ToRollingUpdateDaemonSetPtrOutputWithConte }).(RollingUpdateDaemonSetPtrOutput) } +func (o RollingUpdateDaemonSetOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSet] { + return pulumix.Output[RollingUpdateDaemonSet]{ + OutputState: o.OutputState, + } +} + // The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. func (o RollingUpdateDaemonSetOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDaemonSet) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -5992,6 +6731,12 @@ func (o RollingUpdateDaemonSetPtrOutput) ToRollingUpdateDaemonSetPtrOutputWithCo return o } +func (o RollingUpdateDaemonSetPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSet] { + return pulumix.Output[*RollingUpdateDaemonSet]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDaemonSetPtrOutput) Elem() RollingUpdateDaemonSetOutput { return o.ApplyT(func(v *RollingUpdateDaemonSet) RollingUpdateDaemonSet { if v != nil { @@ -6061,6 +6806,12 @@ func (i RollingUpdateDaemonSetPatchArgs) ToRollingUpdateDaemonSetPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPatchOutput) } +func (i RollingUpdateDaemonSetPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSetPatch] { + return pulumix.Output[RollingUpdateDaemonSetPatch]{ + OutputState: i.ToRollingUpdateDaemonSetPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDaemonSetPatchArgs) ToRollingUpdateDaemonSetPatchPtrOutput() RollingUpdateDaemonSetPatchPtrOutput { return i.ToRollingUpdateDaemonSetPatchPtrOutputWithContext(context.Background()) } @@ -6102,6 +6853,12 @@ func (i *rollingUpdateDaemonSetPatchPtrType) ToRollingUpdateDaemonSetPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPatchPtrOutput) } +func (i *rollingUpdateDaemonSetPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSetPatch] { + return pulumix.Output[*RollingUpdateDaemonSetPatch]{ + OutputState: i.ToRollingUpdateDaemonSetPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of daemon set rolling update. type RollingUpdateDaemonSetPatchOutput struct{ *pulumi.OutputState } @@ -6127,6 +6884,12 @@ func (o RollingUpdateDaemonSetPatchOutput) ToRollingUpdateDaemonSetPatchPtrOutpu }).(RollingUpdateDaemonSetPatchPtrOutput) } +func (o RollingUpdateDaemonSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSetPatch] { + return pulumix.Output[RollingUpdateDaemonSetPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. func (o RollingUpdateDaemonSetPatchOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDaemonSetPatch) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -6151,6 +6914,12 @@ func (o RollingUpdateDaemonSetPatchPtrOutput) ToRollingUpdateDaemonSetPatchPtrOu return o } +func (o RollingUpdateDaemonSetPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSetPatch] { + return pulumix.Output[*RollingUpdateDaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDaemonSetPatchPtrOutput) Elem() RollingUpdateDaemonSetPatchOutput { return o.ApplyT(func(v *RollingUpdateDaemonSetPatch) RollingUpdateDaemonSetPatch { if v != nil { @@ -6220,6 +6989,12 @@ func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentOutput) } +func (i RollingUpdateDeploymentArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentPtrOutput() RollingUpdateDeploymentPtrOutput { return i.ToRollingUpdateDeploymentPtrOutputWithContext(context.Background()) } @@ -6261,6 +7036,12 @@ func (i *rollingUpdateDeploymentPtrType) ToRollingUpdateDeploymentPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPtrOutput) } +func (i *rollingUpdateDeploymentPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentOutput struct{ *pulumi.OutputState } @@ -6286,6 +7067,12 @@ func (o RollingUpdateDeploymentOutput) ToRollingUpdateDeploymentPtrOutputWithCon }).(RollingUpdateDeploymentPtrOutput) } +func (o RollingUpdateDeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeployment) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -6310,6 +7097,12 @@ func (o RollingUpdateDeploymentPtrOutput) ToRollingUpdateDeploymentPtrOutputWith return o } +func (o RollingUpdateDeploymentPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPtrOutput) Elem() RollingUpdateDeploymentOutput { return o.ApplyT(func(v *RollingUpdateDeployment) RollingUpdateDeployment { if v != nil { @@ -6379,6 +7172,12 @@ func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchOutput) } +func (i RollingUpdateDeploymentPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchPtrOutput() RollingUpdateDeploymentPatchPtrOutput { return i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(context.Background()) } @@ -6420,6 +7219,12 @@ func (i *rollingUpdateDeploymentPatchPtrType) ToRollingUpdateDeploymentPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchPtrOutput) } +func (i *rollingUpdateDeploymentPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentPatchOutput struct{ *pulumi.OutputState } @@ -6445,6 +7250,12 @@ func (o RollingUpdateDeploymentPatchOutput) ToRollingUpdateDeploymentPatchPtrOut }).(RollingUpdateDeploymentPatchPtrOutput) } +func (o RollingUpdateDeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentPatchOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeploymentPatch) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -6469,6 +7280,12 @@ func (o RollingUpdateDeploymentPatchPtrOutput) ToRollingUpdateDeploymentPatchPtr return o } +func (o RollingUpdateDeploymentPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPatchPtrOutput) Elem() RollingUpdateDeploymentPatchOutput { return o.ApplyT(func(v *RollingUpdateDeploymentPatch) RollingUpdateDeploymentPatch { if v != nil { @@ -6538,6 +7355,12 @@ func (i RollingUpdateStatefulSetStrategyArgs) ToRollingUpdateStatefulSetStrategy return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyOutput) } +func (i RollingUpdateStatefulSetStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategy] { + return pulumix.Output[RollingUpdateStatefulSetStrategy]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateStatefulSetStrategyArgs) ToRollingUpdateStatefulSetStrategyPtrOutput() RollingUpdateStatefulSetStrategyPtrOutput { return i.ToRollingUpdateStatefulSetStrategyPtrOutputWithContext(context.Background()) } @@ -6579,6 +7402,12 @@ func (i *rollingUpdateStatefulSetStrategyPtrType) ToRollingUpdateStatefulSetStra return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPtrOutput) } +func (i *rollingUpdateStatefulSetStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategy] { + return pulumix.Output[*RollingUpdateStatefulSetStrategy]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. type RollingUpdateStatefulSetStrategyOutput struct{ *pulumi.OutputState } @@ -6604,6 +7433,12 @@ func (o RollingUpdateStatefulSetStrategyOutput) ToRollingUpdateStatefulSetStrate }).(RollingUpdateStatefulSetStrategyPtrOutput) } +func (o RollingUpdateStatefulSetStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategy] { + return pulumix.Output[RollingUpdateStatefulSetStrategy]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). Absolute number is calculated from percentage by rounding up. This can not be 0. Defaults to 1. This field is alpha-level and is only honored by servers that enable the MaxUnavailableStatefulSet feature. The field applies to all pods in the range 0 to Replicas-1. That means if there is any unavailable pod in the range 0 to Replicas-1, it will be counted towards MaxUnavailable. func (o RollingUpdateStatefulSetStrategyOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateStatefulSetStrategy) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -6628,6 +7463,12 @@ func (o RollingUpdateStatefulSetStrategyPtrOutput) ToRollingUpdateStatefulSetStr return o } +func (o RollingUpdateStatefulSetStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategy] { + return pulumix.Output[*RollingUpdateStatefulSetStrategy]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateStatefulSetStrategyPtrOutput) Elem() RollingUpdateStatefulSetStrategyOutput { return o.ApplyT(func(v *RollingUpdateStatefulSetStrategy) RollingUpdateStatefulSetStrategy { if v != nil { @@ -6697,6 +7538,12 @@ func (i RollingUpdateStatefulSetStrategyPatchArgs) ToRollingUpdateStatefulSetStr return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPatchOutput) } +func (i RollingUpdateStatefulSetStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[RollingUpdateStatefulSetStrategyPatch]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateStatefulSetStrategyPatchArgs) ToRollingUpdateStatefulSetStrategyPatchPtrOutput() RollingUpdateStatefulSetStrategyPatchPtrOutput { return i.ToRollingUpdateStatefulSetStrategyPatchPtrOutputWithContext(context.Background()) } @@ -6738,6 +7585,12 @@ func (i *rollingUpdateStatefulSetStrategyPatchPtrType) ToRollingUpdateStatefulSe return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPatchPtrOutput) } +func (i *rollingUpdateStatefulSetStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[*RollingUpdateStatefulSetStrategyPatch]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. type RollingUpdateStatefulSetStrategyPatchOutput struct{ *pulumi.OutputState } @@ -6763,6 +7616,12 @@ func (o RollingUpdateStatefulSetStrategyPatchOutput) ToRollingUpdateStatefulSetS }).(RollingUpdateStatefulSetStrategyPatchPtrOutput) } +func (o RollingUpdateStatefulSetStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[RollingUpdateStatefulSetStrategyPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). Absolute number is calculated from percentage by rounding up. This can not be 0. Defaults to 1. This field is alpha-level and is only honored by servers that enable the MaxUnavailableStatefulSet feature. The field applies to all pods in the range 0 to Replicas-1. That means if there is any unavailable pod in the range 0 to Replicas-1, it will be counted towards MaxUnavailable. func (o RollingUpdateStatefulSetStrategyPatchOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateStatefulSetStrategyPatch) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -6787,6 +7646,12 @@ func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) ToRollingUpdateStatefulS return o } +func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[*RollingUpdateStatefulSetStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) Elem() RollingUpdateStatefulSetStrategyPatchOutput { return o.ApplyT(func(v *RollingUpdateStatefulSetStrategyPatch) RollingUpdateStatefulSetStrategyPatch { if v != nil { @@ -6902,6 +7767,12 @@ func (i StatefulSetTypeArgs) ToStatefulSetTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetTypeOutput) } +func (i StatefulSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetType] { + return pulumix.Output[StatefulSetType]{ + OutputState: i.ToStatefulSetTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSetTypeArrayInput is an input type that accepts StatefulSetTypeArray and StatefulSetTypeArrayOutput values. // You can construct a concrete instance of `StatefulSetTypeArrayInput` via: // @@ -6927,6 +7798,12 @@ func (i StatefulSetTypeArray) ToStatefulSetTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetTypeArrayOutput) } +func (i StatefulSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetType] { + return pulumix.Output[[]StatefulSetType]{ + OutputState: i.ToStatefulSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSet represents a set of pods with consistent identities. Identities are defined as: // - Network: A single stable DNS and hostname. // - Storage: As many VolumeClaims as requested. @@ -6959,6 +7836,12 @@ func (o StatefulSetTypeOutput) ToStatefulSetTypeOutputWithContext(ctx context.Co return o } +func (o StatefulSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetType] { + return pulumix.Output[StatefulSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6998,6 +7881,12 @@ func (o StatefulSetTypeArrayOutput) ToStatefulSetTypeArrayOutputWithContext(ctx return o } +func (o StatefulSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetType] { + return pulumix.Output[[]StatefulSetType]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetTypeArrayOutput) Index(i pulumi.IntInput) StatefulSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetType { return vs[0].([]StatefulSetType)[vs[1].(int)] @@ -7055,6 +7944,12 @@ func (i StatefulSetConditionArgs) ToStatefulSetConditionOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionOutput) } +func (i StatefulSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetCondition] { + return pulumix.Output[StatefulSetCondition]{ + OutputState: i.ToStatefulSetConditionOutputWithContext(ctx).OutputState, + } +} + // StatefulSetConditionArrayInput is an input type that accepts StatefulSetConditionArray and StatefulSetConditionArrayOutput values. // You can construct a concrete instance of `StatefulSetConditionArrayInput` via: // @@ -7080,6 +7975,12 @@ func (i StatefulSetConditionArray) ToStatefulSetConditionArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionArrayOutput) } +func (i StatefulSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetCondition] { + return pulumix.Output[[]StatefulSetCondition]{ + OutputState: i.ToStatefulSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetCondition describes the state of a statefulset at a certain point. type StatefulSetConditionOutput struct{ *pulumi.OutputState } @@ -7095,6 +7996,12 @@ func (o StatefulSetConditionOutput) ToStatefulSetConditionOutputWithContext(ctx return o } +func (o StatefulSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetCondition] { + return pulumix.Output[StatefulSetCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o StatefulSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -7134,6 +8041,12 @@ func (o StatefulSetConditionArrayOutput) ToStatefulSetConditionArrayOutputWithCo return o } +func (o StatefulSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetCondition] { + return pulumix.Output[[]StatefulSetCondition]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetConditionArrayOutput) Index(i pulumi.IntInput) StatefulSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetCondition { return vs[0].([]StatefulSetCondition)[vs[1].(int)] @@ -7191,6 +8104,12 @@ func (i StatefulSetConditionPatchArgs) ToStatefulSetConditionPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionPatchOutput) } +func (i StatefulSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetConditionPatch] { + return pulumix.Output[StatefulSetConditionPatch]{ + OutputState: i.ToStatefulSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // StatefulSetConditionPatchArrayInput is an input type that accepts StatefulSetConditionPatchArray and StatefulSetConditionPatchArrayOutput values. // You can construct a concrete instance of `StatefulSetConditionPatchArrayInput` via: // @@ -7216,6 +8135,12 @@ func (i StatefulSetConditionPatchArray) ToStatefulSetConditionPatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionPatchArrayOutput) } +func (i StatefulSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetConditionPatch] { + return pulumix.Output[[]StatefulSetConditionPatch]{ + OutputState: i.ToStatefulSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetCondition describes the state of a statefulset at a certain point. type StatefulSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -7231,6 +8156,12 @@ func (o StatefulSetConditionPatchOutput) ToStatefulSetConditionPatchOutputWithCo return o } +func (o StatefulSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetConditionPatch] { + return pulumix.Output[StatefulSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o StatefulSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -7270,6 +8201,12 @@ func (o StatefulSetConditionPatchArrayOutput) ToStatefulSetConditionPatchArrayOu return o } +func (o StatefulSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetConditionPatch] { + return pulumix.Output[[]StatefulSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetConditionPatchArrayOutput) Index(i pulumi.IntInput) StatefulSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetConditionPatch { return vs[0].([]StatefulSetConditionPatch)[vs[1].(int)] @@ -7323,6 +8260,12 @@ func (i StatefulSetListTypeArgs) ToStatefulSetListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListTypeOutput) } +func (i StatefulSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetListType] { + return pulumix.Output[StatefulSetListType]{ + OutputState: i.ToStatefulSetListTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSetList is a collection of StatefulSets. type StatefulSetListTypeOutput struct{ *pulumi.OutputState } @@ -7338,6 +8281,12 @@ func (o StatefulSetListTypeOutput) ToStatefulSetListTypeOutputWithContext(ctx co return o } +func (o StatefulSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetListType] { + return pulumix.Output[StatefulSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7399,6 +8348,12 @@ func (i StatefulSetOrdinalsArgs) ToStatefulSetOrdinalsOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOrdinalsOutput) } +func (i StatefulSetOrdinalsArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetOrdinals] { + return pulumix.Output[StatefulSetOrdinals]{ + OutputState: i.ToStatefulSetOrdinalsOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetOrdinalsArgs) ToStatefulSetOrdinalsPtrOutput() StatefulSetOrdinalsPtrOutput { return i.ToStatefulSetOrdinalsPtrOutputWithContext(context.Background()) } @@ -7440,6 +8395,12 @@ func (i *statefulSetOrdinalsPtrType) ToStatefulSetOrdinalsPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOrdinalsPtrOutput) } +func (i *statefulSetOrdinalsPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetOrdinals] { + return pulumix.Output[*StatefulSetOrdinals]{ + OutputState: i.ToStatefulSetOrdinalsPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetOrdinals describes the policy used for replica ordinal assignment in this StatefulSet. type StatefulSetOrdinalsOutput struct{ *pulumi.OutputState } @@ -7465,6 +8426,12 @@ func (o StatefulSetOrdinalsOutput) ToStatefulSetOrdinalsPtrOutputWithContext(ctx }).(StatefulSetOrdinalsPtrOutput) } +func (o StatefulSetOrdinalsOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetOrdinals] { + return pulumix.Output[StatefulSetOrdinals]{ + OutputState: o.OutputState, + } +} + // start is the number representing the first replica's index. It may be used to number replicas from an alternate index (eg: 1-indexed) over the default 0-indexed names, or to orchestrate progressive movement of replicas from one StatefulSet to another. If set, replica indices will be in the range: // // [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas). @@ -7490,6 +8457,12 @@ func (o StatefulSetOrdinalsPtrOutput) ToStatefulSetOrdinalsPtrOutputWithContext( return o } +func (o StatefulSetOrdinalsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetOrdinals] { + return pulumix.Output[*StatefulSetOrdinals]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetOrdinalsPtrOutput) Elem() StatefulSetOrdinalsOutput { return o.ApplyT(func(v *StatefulSetOrdinals) StatefulSetOrdinals { if v != nil { @@ -7557,6 +8530,12 @@ func (i StatefulSetOrdinalsPatchArgs) ToStatefulSetOrdinalsPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOrdinalsPatchOutput) } +func (i StatefulSetOrdinalsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetOrdinalsPatch] { + return pulumix.Output[StatefulSetOrdinalsPatch]{ + OutputState: i.ToStatefulSetOrdinalsPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetOrdinalsPatchArgs) ToStatefulSetOrdinalsPatchPtrOutput() StatefulSetOrdinalsPatchPtrOutput { return i.ToStatefulSetOrdinalsPatchPtrOutputWithContext(context.Background()) } @@ -7598,6 +8577,12 @@ func (i *statefulSetOrdinalsPatchPtrType) ToStatefulSetOrdinalsPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOrdinalsPatchPtrOutput) } +func (i *statefulSetOrdinalsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetOrdinalsPatch] { + return pulumix.Output[*StatefulSetOrdinalsPatch]{ + OutputState: i.ToStatefulSetOrdinalsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetOrdinals describes the policy used for replica ordinal assignment in this StatefulSet. type StatefulSetOrdinalsPatchOutput struct{ *pulumi.OutputState } @@ -7623,6 +8608,12 @@ func (o StatefulSetOrdinalsPatchOutput) ToStatefulSetOrdinalsPatchPtrOutputWithC }).(StatefulSetOrdinalsPatchPtrOutput) } +func (o StatefulSetOrdinalsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetOrdinalsPatch] { + return pulumix.Output[StatefulSetOrdinalsPatch]{ + OutputState: o.OutputState, + } +} + // start is the number representing the first replica's index. It may be used to number replicas from an alternate index (eg: 1-indexed) over the default 0-indexed names, or to orchestrate progressive movement of replicas from one StatefulSet to another. If set, replica indices will be in the range: // // [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas). @@ -7648,6 +8639,12 @@ func (o StatefulSetOrdinalsPatchPtrOutput) ToStatefulSetOrdinalsPatchPtrOutputWi return o } +func (o StatefulSetOrdinalsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetOrdinalsPatch] { + return pulumix.Output[*StatefulSetOrdinalsPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetOrdinalsPatchPtrOutput) Elem() StatefulSetOrdinalsPatchOutput { return o.ApplyT(func(v *StatefulSetOrdinalsPatch) StatefulSetOrdinalsPatch { if v != nil { @@ -7759,6 +8756,12 @@ func (i StatefulSetPatchTypeArgs) ToStatefulSetPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchTypeOutput) } +func (i StatefulSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPatchType] { + return pulumix.Output[StatefulSetPatchType]{ + OutputState: i.ToStatefulSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSet represents a set of pods with consistent identities. Identities are defined as: // - Network: A single stable DNS and hostname. // - Storage: As many VolumeClaims as requested. @@ -7791,6 +8794,12 @@ func (o StatefulSetPatchTypeOutput) ToStatefulSetPatchTypeOutputWithContext(ctx return o } +func (o StatefulSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPatchType] { + return pulumix.Output[StatefulSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7855,6 +8864,12 @@ func (i StatefulSetPersistentVolumeClaimRetentionPolicyArgs) ToStatefulSetPersis return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPersistentVolumeClaimRetentionPolicyOutput) } +func (i StatefulSetPersistentVolumeClaimRetentionPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicy] { + return pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicy]{ + OutputState: i.ToStatefulSetPersistentVolumeClaimRetentionPolicyOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetPersistentVolumeClaimRetentionPolicyArgs) ToStatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput() StatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput { return i.ToStatefulSetPersistentVolumeClaimRetentionPolicyPtrOutputWithContext(context.Background()) } @@ -7896,6 +8911,12 @@ func (i *statefulSetPersistentVolumeClaimRetentionPolicyPtrType) ToStatefulSetPe return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput) } +func (i *statefulSetPersistentVolumeClaimRetentionPolicyPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicy] { + return pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicy]{ + OutputState: i.ToStatefulSetPersistentVolumeClaimRetentionPolicyPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates. type StatefulSetPersistentVolumeClaimRetentionPolicyOutput struct{ *pulumi.OutputState } @@ -7921,6 +8942,12 @@ func (o StatefulSetPersistentVolumeClaimRetentionPolicyOutput) ToStatefulSetPers }).(StatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput) } +func (o StatefulSetPersistentVolumeClaimRetentionPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicy] { + return pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicy]{ + OutputState: o.OutputState, + } +} + // WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted. func (o StatefulSetPersistentVolumeClaimRetentionPolicyOutput) WhenDeleted() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetPersistentVolumeClaimRetentionPolicy) *string { return v.WhenDeleted }).(pulumi.StringPtrOutput) @@ -7945,6 +8972,12 @@ func (o StatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput) ToStatefulSetP return o } +func (o StatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicy] { + return pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicy]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPersistentVolumeClaimRetentionPolicyPtrOutput) Elem() StatefulSetPersistentVolumeClaimRetentionPolicyOutput { return o.ApplyT(func(v *StatefulSetPersistentVolumeClaimRetentionPolicy) StatefulSetPersistentVolumeClaimRetentionPolicy { if v != nil { @@ -8014,6 +9047,12 @@ func (i StatefulSetPersistentVolumeClaimRetentionPolicyPatchArgs) ToStatefulSetP return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPersistentVolumeClaimRetentionPolicyPatchOutput) } +func (i StatefulSetPersistentVolumeClaimRetentionPolicyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicyPatch] { + return pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicyPatch]{ + OutputState: i.ToStatefulSetPersistentVolumeClaimRetentionPolicyPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetPersistentVolumeClaimRetentionPolicyPatchArgs) ToStatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput() StatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput { return i.ToStatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutputWithContext(context.Background()) } @@ -8055,6 +9094,12 @@ func (i *statefulSetPersistentVolumeClaimRetentionPolicyPatchPtrType) ToStateful return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput) } +func (i *statefulSetPersistentVolumeClaimRetentionPolicyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicyPatch] { + return pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicyPatch]{ + OutputState: i.ToStatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates. type StatefulSetPersistentVolumeClaimRetentionPolicyPatchOutput struct{ *pulumi.OutputState } @@ -8080,6 +9125,12 @@ func (o StatefulSetPersistentVolumeClaimRetentionPolicyPatchOutput) ToStatefulSe }).(StatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput) } +func (o StatefulSetPersistentVolumeClaimRetentionPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicyPatch] { + return pulumix.Output[StatefulSetPersistentVolumeClaimRetentionPolicyPatch]{ + OutputState: o.OutputState, + } +} + // WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted. func (o StatefulSetPersistentVolumeClaimRetentionPolicyPatchOutput) WhenDeleted() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetPersistentVolumeClaimRetentionPolicyPatch) *string { return v.WhenDeleted }).(pulumi.StringPtrOutput) @@ -8104,6 +9155,12 @@ func (o StatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput) ToStatefu return o } +func (o StatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicyPatch] { + return pulumix.Output[*StatefulSetPersistentVolumeClaimRetentionPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPersistentVolumeClaimRetentionPolicyPatchPtrOutput) Elem() StatefulSetPersistentVolumeClaimRetentionPolicyPatchOutput { return o.ApplyT(func(v *StatefulSetPersistentVolumeClaimRetentionPolicyPatch) StatefulSetPersistentVolumeClaimRetentionPolicyPatch { if v != nil { @@ -8209,6 +9266,12 @@ func (i StatefulSetSpecArgs) ToStatefulSetSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecOutput) } +func (i StatefulSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpec] { + return pulumix.Output[StatefulSetSpec]{ + OutputState: i.ToStatefulSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetSpecArgs) ToStatefulSetSpecPtrOutput() StatefulSetSpecPtrOutput { return i.ToStatefulSetSpecPtrOutputWithContext(context.Background()) } @@ -8250,6 +9313,12 @@ func (i *statefulSetSpecPtrType) ToStatefulSetSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPtrOutput) } +func (i *statefulSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpec] { + return pulumix.Output[*StatefulSetSpec]{ + OutputState: i.ToStatefulSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpecOutput struct{ *pulumi.OutputState } @@ -8275,6 +9344,12 @@ func (o StatefulSetSpecOutput) ToStatefulSetSpecPtrOutputWithContext(ctx context }).(StatefulSetSpecPtrOutput) } +func (o StatefulSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpec] { + return pulumix.Output[StatefulSetSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o StatefulSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -8346,6 +9421,12 @@ func (o StatefulSetSpecPtrOutput) ToStatefulSetSpecPtrOutputWithContext(ctx cont return o } +func (o StatefulSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpec] { + return pulumix.Output[*StatefulSetSpec]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetSpecPtrOutput) Elem() StatefulSetSpecOutput { return o.ApplyT(func(v *StatefulSetSpec) StatefulSetSpec { if v != nil { @@ -8541,6 +9622,12 @@ func (i StatefulSetSpecPatchArgs) ToStatefulSetSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPatchOutput) } +func (i StatefulSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpecPatch] { + return pulumix.Output[StatefulSetSpecPatch]{ + OutputState: i.ToStatefulSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetSpecPatchArgs) ToStatefulSetSpecPatchPtrOutput() StatefulSetSpecPatchPtrOutput { return i.ToStatefulSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -8582,6 +9669,12 @@ func (i *statefulSetSpecPatchPtrType) ToStatefulSetSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPatchPtrOutput) } +func (i *statefulSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpecPatch] { + return pulumix.Output[*StatefulSetSpecPatch]{ + OutputState: i.ToStatefulSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -8607,6 +9700,12 @@ func (o StatefulSetSpecPatchOutput) ToStatefulSetSpecPatchPtrOutputWithContext(c }).(StatefulSetSpecPatchPtrOutput) } +func (o StatefulSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpecPatch] { + return pulumix.Output[StatefulSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o StatefulSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -8678,6 +9777,12 @@ func (o StatefulSetSpecPatchPtrOutput) ToStatefulSetSpecPatchPtrOutputWithContex return o } +func (o StatefulSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpecPatch] { + return pulumix.Output[*StatefulSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetSpecPatchPtrOutput) Elem() StatefulSetSpecPatchOutput { return o.ApplyT(func(v *StatefulSetSpecPatch) StatefulSetSpecPatch { if v != nil { @@ -8869,6 +9974,12 @@ func (i StatefulSetStatusArgs) ToStatefulSetStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusOutput) } +func (i StatefulSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatus] { + return pulumix.Output[StatefulSetStatus]{ + OutputState: i.ToStatefulSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetStatusArgs) ToStatefulSetStatusPtrOutput() StatefulSetStatusPtrOutput { return i.ToStatefulSetStatusPtrOutputWithContext(context.Background()) } @@ -8910,6 +10021,12 @@ func (i *statefulSetStatusPtrType) ToStatefulSetStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPtrOutput) } +func (i *statefulSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatus] { + return pulumix.Output[*StatefulSetStatus]{ + OutputState: i.ToStatefulSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetStatus represents the current state of a StatefulSet. type StatefulSetStatusOutput struct{ *pulumi.OutputState } @@ -8935,6 +10052,12 @@ func (o StatefulSetStatusOutput) ToStatefulSetStatusPtrOutputWithContext(ctx con }).(StatefulSetStatusPtrOutput) } +func (o StatefulSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatus] { + return pulumix.Output[StatefulSetStatus]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. func (o StatefulSetStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -8999,6 +10122,12 @@ func (o StatefulSetStatusPtrOutput) ToStatefulSetStatusPtrOutputWithContext(ctx return o } +func (o StatefulSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatus] { + return pulumix.Output[*StatefulSetStatus]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetStatusPtrOutput) Elem() StatefulSetStatusOutput { return o.ApplyT(func(v *StatefulSetStatus) StatefulSetStatus { if v != nil { @@ -9180,6 +10309,12 @@ func (i StatefulSetStatusPatchArgs) ToStatefulSetStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPatchOutput) } +func (i StatefulSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatusPatch] { + return pulumix.Output[StatefulSetStatusPatch]{ + OutputState: i.ToStatefulSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetStatusPatchArgs) ToStatefulSetStatusPatchPtrOutput() StatefulSetStatusPatchPtrOutput { return i.ToStatefulSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -9221,6 +10356,12 @@ func (i *statefulSetStatusPatchPtrType) ToStatefulSetStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPatchPtrOutput) } +func (i *statefulSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatusPatch] { + return pulumix.Output[*StatefulSetStatusPatch]{ + OutputState: i.ToStatefulSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetStatus represents the current state of a StatefulSet. type StatefulSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -9246,6 +10387,12 @@ func (o StatefulSetStatusPatchOutput) ToStatefulSetStatusPatchPtrOutputWithConte }).(StatefulSetStatusPatchPtrOutput) } +func (o StatefulSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatusPatch] { + return pulumix.Output[StatefulSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. func (o StatefulSetStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -9310,6 +10457,12 @@ func (o StatefulSetStatusPatchPtrOutput) ToStatefulSetStatusPatchPtrOutputWithCo return o } +func (o StatefulSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatusPatch] { + return pulumix.Output[*StatefulSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetStatusPatchPtrOutput) Elem() StatefulSetStatusPatchOutput { return o.ApplyT(func(v *StatefulSetStatusPatch) StatefulSetStatusPatch { if v != nil { @@ -9459,6 +10612,12 @@ func (i StatefulSetUpdateStrategyArgs) ToStatefulSetUpdateStrategyOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyOutput) } +func (i StatefulSetUpdateStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategy] { + return pulumix.Output[StatefulSetUpdateStrategy]{ + OutputState: i.ToStatefulSetUpdateStrategyOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetUpdateStrategyArgs) ToStatefulSetUpdateStrategyPtrOutput() StatefulSetUpdateStrategyPtrOutput { return i.ToStatefulSetUpdateStrategyPtrOutputWithContext(context.Background()) } @@ -9500,6 +10659,12 @@ func (i *statefulSetUpdateStrategyPtrType) ToStatefulSetUpdateStrategyPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPtrOutput) } +func (i *statefulSetUpdateStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategy] { + return pulumix.Output[*StatefulSetUpdateStrategy]{ + OutputState: i.ToStatefulSetUpdateStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. type StatefulSetUpdateStrategyOutput struct{ *pulumi.OutputState } @@ -9525,6 +10690,12 @@ func (o StatefulSetUpdateStrategyOutput) ToStatefulSetUpdateStrategyPtrOutputWit }).(StatefulSetUpdateStrategyPtrOutput) } +func (o StatefulSetUpdateStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategy] { + return pulumix.Output[StatefulSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. func (o StatefulSetUpdateStrategyOutput) RollingUpdate() RollingUpdateStatefulSetStrategyPtrOutput { return o.ApplyT(func(v StatefulSetUpdateStrategy) *RollingUpdateStatefulSetStrategy { return v.RollingUpdate }).(RollingUpdateStatefulSetStrategyPtrOutput) @@ -9549,6 +10720,12 @@ func (o StatefulSetUpdateStrategyPtrOutput) ToStatefulSetUpdateStrategyPtrOutput return o } +func (o StatefulSetUpdateStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategy] { + return pulumix.Output[*StatefulSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetUpdateStrategyPtrOutput) Elem() StatefulSetUpdateStrategyOutput { return o.ApplyT(func(v *StatefulSetUpdateStrategy) StatefulSetUpdateStrategy { if v != nil { @@ -9618,6 +10795,12 @@ func (i StatefulSetUpdateStrategyPatchArgs) ToStatefulSetUpdateStrategyPatchOutp return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPatchOutput) } +func (i StatefulSetUpdateStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategyPatch] { + return pulumix.Output[StatefulSetUpdateStrategyPatch]{ + OutputState: i.ToStatefulSetUpdateStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetUpdateStrategyPatchArgs) ToStatefulSetUpdateStrategyPatchPtrOutput() StatefulSetUpdateStrategyPatchPtrOutput { return i.ToStatefulSetUpdateStrategyPatchPtrOutputWithContext(context.Background()) } @@ -9659,6 +10842,12 @@ func (i *statefulSetUpdateStrategyPatchPtrType) ToStatefulSetUpdateStrategyPatch return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPatchPtrOutput) } +func (i *statefulSetUpdateStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategyPatch] { + return pulumix.Output[*StatefulSetUpdateStrategyPatch]{ + OutputState: i.ToStatefulSetUpdateStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. type StatefulSetUpdateStrategyPatchOutput struct{ *pulumi.OutputState } @@ -9684,6 +10873,12 @@ func (o StatefulSetUpdateStrategyPatchOutput) ToStatefulSetUpdateStrategyPatchPt }).(StatefulSetUpdateStrategyPatchPtrOutput) } +func (o StatefulSetUpdateStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategyPatch] { + return pulumix.Output[StatefulSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. func (o StatefulSetUpdateStrategyPatchOutput) RollingUpdate() RollingUpdateStatefulSetStrategyPatchPtrOutput { return o.ApplyT(func(v StatefulSetUpdateStrategyPatch) *RollingUpdateStatefulSetStrategyPatch { return v.RollingUpdate }).(RollingUpdateStatefulSetStrategyPatchPtrOutput) @@ -9708,6 +10903,12 @@ func (o StatefulSetUpdateStrategyPatchPtrOutput) ToStatefulSetUpdateStrategyPatc return o } +func (o StatefulSetUpdateStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategyPatch] { + return pulumix.Output[*StatefulSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetUpdateStrategyPatchPtrOutput) Elem() StatefulSetUpdateStrategyPatchOutput { return o.ApplyT(func(v *StatefulSetUpdateStrategyPatch) StatefulSetUpdateStrategyPatch { if v != nil { diff --git a/sdk/go/kubernetes/apps/v1/replicaSet.go b/sdk/go/kubernetes/apps/v1/replicaSet.go index e4e6c6a6ba..496fced302 100644 --- a/sdk/go/kubernetes/apps/v1/replicaSet.go +++ b/sdk/go/kubernetes/apps/v1/replicaSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicaSet ensures that a specified number of pod replicas are running at any given time. @@ -124,6 +125,12 @@ func (i *ReplicaSet) ToReplicaSetOutputWithContext(ctx context.Context) ReplicaS return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetOutput) } +func (i *ReplicaSet) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSet] { + return pulumix.Output[*ReplicaSet]{ + OutputState: i.ToReplicaSetOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetArrayInput is an input type that accepts ReplicaSetArray and ReplicaSetArrayOutput values. // You can construct a concrete instance of `ReplicaSetArrayInput` via: // @@ -149,6 +156,12 @@ func (i ReplicaSetArray) ToReplicaSetArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetArrayOutput) } +func (i ReplicaSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSet] { + return pulumix.Output[[]*ReplicaSet]{ + OutputState: i.ToReplicaSetArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetMapInput is an input type that accepts ReplicaSetMap and ReplicaSetMapOutput values. // You can construct a concrete instance of `ReplicaSetMapInput` via: // @@ -174,6 +187,12 @@ func (i ReplicaSetMap) ToReplicaSetMapOutputWithContext(ctx context.Context) Rep return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetMapOutput) } +func (i ReplicaSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSet] { + return pulumix.Output[map[string]*ReplicaSet]{ + OutputState: i.ToReplicaSetMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetOutput struct{ *pulumi.OutputState } func (ReplicaSetOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o ReplicaSetOutput) ToReplicaSetOutputWithContext(ctx context.Context) Rep return o } +func (o ReplicaSetOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSet] { + return pulumix.Output[*ReplicaSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicaSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -227,6 +252,12 @@ func (o ReplicaSetArrayOutput) ToReplicaSetArrayOutputWithContext(ctx context.Co return o } +func (o ReplicaSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSet] { + return pulumix.Output[[]*ReplicaSet]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetArrayOutput) Index(i pulumi.IntInput) ReplicaSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSet { return vs[0].([]*ReplicaSet)[vs[1].(int)] @@ -247,6 +278,12 @@ func (o ReplicaSetMapOutput) ToReplicaSetMapOutputWithContext(ctx context.Contex return o } +func (o ReplicaSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSet] { + return pulumix.Output[map[string]*ReplicaSet]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSet { return vs[0].(map[string]*ReplicaSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/replicaSetList.go b/sdk/go/kubernetes/apps/v1/replicaSetList.go index 5901e1cf0e..c13e769b91 100644 --- a/sdk/go/kubernetes/apps/v1/replicaSetList.go +++ b/sdk/go/kubernetes/apps/v1/replicaSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicaSetList is a collection of ReplicaSets. @@ -117,6 +118,12 @@ func (i *ReplicaSetList) ToReplicaSetListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListOutput) } +func (i *ReplicaSetList) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetList] { + return pulumix.Output[*ReplicaSetList]{ + OutputState: i.ToReplicaSetListOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetListArrayInput is an input type that accepts ReplicaSetListArray and ReplicaSetListArrayOutput values. // You can construct a concrete instance of `ReplicaSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ReplicaSetListArray) ToReplicaSetListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListArrayOutput) } +func (i ReplicaSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetList] { + return pulumix.Output[[]*ReplicaSetList]{ + OutputState: i.ToReplicaSetListArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetListMapInput is an input type that accepts ReplicaSetListMap and ReplicaSetListMapOutput values. // You can construct a concrete instance of `ReplicaSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i ReplicaSetListMap) ToReplicaSetListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListMapOutput) } +func (i ReplicaSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetList] { + return pulumix.Output[map[string]*ReplicaSetList]{ + OutputState: i.ToReplicaSetListMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetListOutput struct{ *pulumi.OutputState } func (ReplicaSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ReplicaSetListOutput) ToReplicaSetListOutputWithContext(ctx context.Cont return o } +func (o ReplicaSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetList] { + return pulumix.Output[*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicaSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ReplicaSetListArrayOutput) ToReplicaSetListArrayOutputWithContext(ctx co return o } +func (o ReplicaSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetList] { + return pulumix.Output[[]*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetListArrayOutput) Index(i pulumi.IntInput) ReplicaSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSetList { return vs[0].([]*ReplicaSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ReplicaSetListMapOutput) ToReplicaSetListMapOutputWithContext(ctx contex return o } +func (o ReplicaSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetList] { + return pulumix.Output[map[string]*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetListMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSetList { return vs[0].(map[string]*ReplicaSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/replicaSetPatch.go b/sdk/go/kubernetes/apps/v1/replicaSetPatch.go index a502260f53..c097975c26 100644 --- a/sdk/go/kubernetes/apps/v1/replicaSetPatch.go +++ b/sdk/go/kubernetes/apps/v1/replicaSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *ReplicaSetPatch) ToReplicaSetPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchOutput) } +func (i *ReplicaSetPatch) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetPatch] { + return pulumix.Output[*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetPatchArrayInput is an input type that accepts ReplicaSetPatchArray and ReplicaSetPatchArrayOutput values. // You can construct a concrete instance of `ReplicaSetPatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i ReplicaSetPatchArray) ToReplicaSetPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchArrayOutput) } +func (i ReplicaSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetPatch] { + return pulumix.Output[[]*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetPatchMapInput is an input type that accepts ReplicaSetPatchMap and ReplicaSetPatchMapOutput values. // You can construct a concrete instance of `ReplicaSetPatchMapInput` via: // @@ -180,6 +193,12 @@ func (i ReplicaSetPatchMap) ToReplicaSetPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchMapOutput) } +func (i ReplicaSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetPatch] { + return pulumix.Output[map[string]*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetPatchOutput struct{ *pulumi.OutputState } func (ReplicaSetPatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o ReplicaSetPatchOutput) ToReplicaSetPatchOutputWithContext(ctx context.Co return o } +func (o ReplicaSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetPatch] { + return pulumix.Output[*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ReplicaSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -233,6 +258,12 @@ func (o ReplicaSetPatchArrayOutput) ToReplicaSetPatchArrayOutputWithContext(ctx return o } +func (o ReplicaSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetPatch] { + return pulumix.Output[[]*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetPatchArrayOutput) Index(i pulumi.IntInput) ReplicaSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSetPatch { return vs[0].([]*ReplicaSetPatch)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o ReplicaSetPatchMapOutput) ToReplicaSetPatchMapOutputWithContext(ctx cont return o } +func (o ReplicaSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetPatch] { + return pulumix.Output[map[string]*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetPatchMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSetPatch { return vs[0].(map[string]*ReplicaSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/statefulSet.go b/sdk/go/kubernetes/apps/v1/statefulSet.go index e70ba7abfd..3c4aaedd63 100644 --- a/sdk/go/kubernetes/apps/v1/statefulSet.go +++ b/sdk/go/kubernetes/apps/v1/statefulSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StatefulSet represents a set of pods with consistent identities. Identities are defined as: @@ -353,6 +354,12 @@ func (i *StatefulSet) ToStatefulSetOutputWithContext(ctx context.Context) Statef return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOutput) } +func (i *StatefulSet) ToOutput(ctx context.Context) pulumix.Output[*StatefulSet] { + return pulumix.Output[*StatefulSet]{ + OutputState: i.ToStatefulSetOutputWithContext(ctx).OutputState, + } +} + // StatefulSetArrayInput is an input type that accepts StatefulSetArray and StatefulSetArrayOutput values. // You can construct a concrete instance of `StatefulSetArrayInput` via: // @@ -378,6 +385,12 @@ func (i StatefulSetArray) ToStatefulSetArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetArrayOutput) } +func (i StatefulSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSet] { + return pulumix.Output[[]*StatefulSet]{ + OutputState: i.ToStatefulSetArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetMapInput is an input type that accepts StatefulSetMap and StatefulSetMapOutput values. // You can construct a concrete instance of `StatefulSetMapInput` via: // @@ -403,6 +416,12 @@ func (i StatefulSetMap) ToStatefulSetMapOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(StatefulSetMapOutput) } +func (i StatefulSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSet] { + return pulumix.Output[map[string]*StatefulSet]{ + OutputState: i.ToStatefulSetMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetOutput struct{ *pulumi.OutputState } func (StatefulSetOutput) ElementType() reflect.Type { @@ -417,6 +436,12 @@ func (o StatefulSetOutput) ToStatefulSetOutputWithContext(ctx context.Context) S return o } +func (o StatefulSetOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSet] { + return pulumix.Output[*StatefulSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StatefulSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -456,6 +481,12 @@ func (o StatefulSetArrayOutput) ToStatefulSetArrayOutputWithContext(ctx context. return o } +func (o StatefulSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSet] { + return pulumix.Output[[]*StatefulSet]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetArrayOutput) Index(i pulumi.IntInput) StatefulSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSet { return vs[0].([]*StatefulSet)[vs[1].(int)] @@ -476,6 +507,12 @@ func (o StatefulSetMapOutput) ToStatefulSetMapOutputWithContext(ctx context.Cont return o } +func (o StatefulSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSet] { + return pulumix.Output[map[string]*StatefulSet]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetMapOutput) MapIndex(k pulumi.StringInput) StatefulSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSet { return vs[0].(map[string]*StatefulSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/statefulSetList.go b/sdk/go/kubernetes/apps/v1/statefulSetList.go index 144adea29a..073e2d0b3e 100644 --- a/sdk/go/kubernetes/apps/v1/statefulSetList.go +++ b/sdk/go/kubernetes/apps/v1/statefulSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StatefulSetList is a collection of StatefulSets. @@ -117,6 +118,12 @@ func (i *StatefulSetList) ToStatefulSetListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListOutput) } +func (i *StatefulSetList) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetList] { + return pulumix.Output[*StatefulSetList]{ + OutputState: i.ToStatefulSetListOutputWithContext(ctx).OutputState, + } +} + // StatefulSetListArrayInput is an input type that accepts StatefulSetListArray and StatefulSetListArrayOutput values. // You can construct a concrete instance of `StatefulSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i StatefulSetListArray) ToStatefulSetListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListArrayOutput) } +func (i StatefulSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetList] { + return pulumix.Output[[]*StatefulSetList]{ + OutputState: i.ToStatefulSetListArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetListMapInput is an input type that accepts StatefulSetListMap and StatefulSetListMapOutput values. // You can construct a concrete instance of `StatefulSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i StatefulSetListMap) ToStatefulSetListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListMapOutput) } +func (i StatefulSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetList] { + return pulumix.Output[map[string]*StatefulSetList]{ + OutputState: i.ToStatefulSetListMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetListOutput struct{ *pulumi.OutputState } func (StatefulSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o StatefulSetListOutput) ToStatefulSetListOutputWithContext(ctx context.Co return o } +func (o StatefulSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetList] { + return pulumix.Output[*StatefulSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StatefulSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o StatefulSetListArrayOutput) ToStatefulSetListArrayOutputWithContext(ctx return o } +func (o StatefulSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetList] { + return pulumix.Output[[]*StatefulSetList]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetListArrayOutput) Index(i pulumi.IntInput) StatefulSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSetList { return vs[0].([]*StatefulSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o StatefulSetListMapOutput) ToStatefulSetListMapOutputWithContext(ctx cont return o } +func (o StatefulSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetList] { + return pulumix.Output[map[string]*StatefulSetList]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetListMapOutput) MapIndex(k pulumi.StringInput) StatefulSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSetList { return vs[0].(map[string]*StatefulSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1/statefulSetPatch.go b/sdk/go/kubernetes/apps/v1/statefulSetPatch.go index 1e8510c6a8..f8f26f97d9 100644 --- a/sdk/go/kubernetes/apps/v1/statefulSetPatch.go +++ b/sdk/go/kubernetes/apps/v1/statefulSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -147,6 +148,12 @@ func (i *StatefulSetPatch) ToStatefulSetPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchOutput) } +func (i *StatefulSetPatch) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPatch] { + return pulumix.Output[*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPatchArrayInput is an input type that accepts StatefulSetPatchArray and StatefulSetPatchArrayOutput values. // You can construct a concrete instance of `StatefulSetPatchArrayInput` via: // @@ -172,6 +179,12 @@ func (i StatefulSetPatchArray) ToStatefulSetPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchArrayOutput) } +func (i StatefulSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetPatch] { + return pulumix.Output[[]*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPatchMapInput is an input type that accepts StatefulSetPatchMap and StatefulSetPatchMapOutput values. // You can construct a concrete instance of `StatefulSetPatchMapInput` via: // @@ -197,6 +210,12 @@ func (i StatefulSetPatchMap) ToStatefulSetPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchMapOutput) } +func (i StatefulSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetPatch] { + return pulumix.Output[map[string]*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetPatchOutput struct{ *pulumi.OutputState } func (StatefulSetPatchOutput) ElementType() reflect.Type { @@ -211,6 +230,12 @@ func (o StatefulSetPatchOutput) ToStatefulSetPatchOutputWithContext(ctx context. return o } +func (o StatefulSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPatch] { + return pulumix.Output[*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *StatefulSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -250,6 +275,12 @@ func (o StatefulSetPatchArrayOutput) ToStatefulSetPatchArrayOutputWithContext(ct return o } +func (o StatefulSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetPatch] { + return pulumix.Output[[]*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPatchArrayOutput) Index(i pulumi.IntInput) StatefulSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSetPatch { return vs[0].([]*StatefulSetPatch)[vs[1].(int)] @@ -270,6 +301,12 @@ func (o StatefulSetPatchMapOutput) ToStatefulSetPatchMapOutputWithContext(ctx co return o } +func (o StatefulSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetPatch] { + return pulumix.Output[map[string]*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPatchMapOutput) MapIndex(k pulumi.StringInput) StatefulSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSetPatch { return vs[0].(map[string]*StatefulSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/controllerRevision.go b/sdk/go/kubernetes/apps/v1beta1/controllerRevision.go index 33d9b63c34..084253c9fd 100644 --- a/sdk/go/kubernetes/apps/v1beta1/controllerRevision.go +++ b/sdk/go/kubernetes/apps/v1beta1/controllerRevision.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. @@ -134,6 +135,12 @@ func (i *ControllerRevision) ToControllerRevisionOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionOutput) } +func (i *ControllerRevision) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevision] { + return pulumix.Output[*ControllerRevision]{ + OutputState: i.ToControllerRevisionOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionArrayInput is an input type that accepts ControllerRevisionArray and ControllerRevisionArrayOutput values. // You can construct a concrete instance of `ControllerRevisionArrayInput` via: // @@ -159,6 +166,12 @@ func (i ControllerRevisionArray) ToControllerRevisionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionArrayOutput) } +func (i ControllerRevisionArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevision] { + return pulumix.Output[[]*ControllerRevision]{ + OutputState: i.ToControllerRevisionArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionMapInput is an input type that accepts ControllerRevisionMap and ControllerRevisionMapOutput values. // You can construct a concrete instance of `ControllerRevisionMapInput` via: // @@ -184,6 +197,12 @@ func (i ControllerRevisionMap) ToControllerRevisionMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionMapOutput) } +func (i ControllerRevisionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevision] { + return pulumix.Output[map[string]*ControllerRevision]{ + OutputState: i.ToControllerRevisionMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionOutput struct{ *pulumi.OutputState } func (ControllerRevisionOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ControllerRevisionOutput) ToControllerRevisionOutputWithContext(ctx cont return o } +func (o ControllerRevisionOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevision] { + return pulumix.Output[*ControllerRevision]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ControllerRevision) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -237,6 +262,12 @@ func (o ControllerRevisionArrayOutput) ToControllerRevisionArrayOutputWithContex return o } +func (o ControllerRevisionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevision] { + return pulumix.Output[[]*ControllerRevision]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionArrayOutput) Index(i pulumi.IntInput) ControllerRevisionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevision { return vs[0].([]*ControllerRevision)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ControllerRevisionMapOutput) ToControllerRevisionMapOutputWithContext(ct return o } +func (o ControllerRevisionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevision] { + return pulumix.Output[map[string]*ControllerRevision]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevision { return vs[0].(map[string]*ControllerRevision)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/controllerRevisionList.go b/sdk/go/kubernetes/apps/v1beta1/controllerRevisionList.go index 6d539f4c44..cdb8ed2683 100644 --- a/sdk/go/kubernetes/apps/v1beta1/controllerRevisionList.go +++ b/sdk/go/kubernetes/apps/v1beta1/controllerRevisionList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ControllerRevisionList is a resource containing a list of ControllerRevision objects. @@ -117,6 +118,12 @@ func (i *ControllerRevisionList) ToControllerRevisionListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListOutput) } +func (i *ControllerRevisionList) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionList] { + return pulumix.Output[*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionListArrayInput is an input type that accepts ControllerRevisionListArray and ControllerRevisionListArrayOutput values. // You can construct a concrete instance of `ControllerRevisionListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ControllerRevisionListArray) ToControllerRevisionListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListArrayOutput) } +func (i ControllerRevisionListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionList] { + return pulumix.Output[[]*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionListMapInput is an input type that accepts ControllerRevisionListMap and ControllerRevisionListMapOutput values. // You can construct a concrete instance of `ControllerRevisionListMapInput` via: // @@ -167,6 +180,12 @@ func (i ControllerRevisionListMap) ToControllerRevisionListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListMapOutput) } +func (i ControllerRevisionListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionList] { + return pulumix.Output[map[string]*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionListOutput struct{ *pulumi.OutputState } func (ControllerRevisionListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ControllerRevisionListOutput) ToControllerRevisionListOutputWithContext( return o } +func (o ControllerRevisionListOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionList] { + return pulumix.Output[*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ControllerRevisionList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ControllerRevisionListArrayOutput) ToControllerRevisionListArrayOutputWi return o } +func (o ControllerRevisionListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionList] { + return pulumix.Output[[]*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionListArrayOutput) Index(i pulumi.IntInput) ControllerRevisionListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevisionList { return vs[0].([]*ControllerRevisionList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ControllerRevisionListMapOutput) ToControllerRevisionListMapOutputWithCo return o } +func (o ControllerRevisionListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionList] { + return pulumix.Output[map[string]*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionListMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevisionList { return vs[0].(map[string]*ControllerRevisionList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/controllerRevisionPatch.go b/sdk/go/kubernetes/apps/v1beta1/controllerRevisionPatch.go index ff8e731986..9eada72181 100644 --- a/sdk/go/kubernetes/apps/v1beta1/controllerRevisionPatch.go +++ b/sdk/go/kubernetes/apps/v1beta1/controllerRevisionPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -136,6 +137,12 @@ func (i *ControllerRevisionPatch) ToControllerRevisionPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchOutput) } +func (i *ControllerRevisionPatch) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionPatch] { + return pulumix.Output[*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionPatchArrayInput is an input type that accepts ControllerRevisionPatchArray and ControllerRevisionPatchArrayOutput values. // You can construct a concrete instance of `ControllerRevisionPatchArrayInput` via: // @@ -161,6 +168,12 @@ func (i ControllerRevisionPatchArray) ToControllerRevisionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchArrayOutput) } +func (i ControllerRevisionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionPatch] { + return pulumix.Output[[]*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionPatchMapInput is an input type that accepts ControllerRevisionPatchMap and ControllerRevisionPatchMapOutput values. // You can construct a concrete instance of `ControllerRevisionPatchMapInput` via: // @@ -186,6 +199,12 @@ func (i ControllerRevisionPatchMap) ToControllerRevisionPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchMapOutput) } +func (i ControllerRevisionPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionPatch] { + return pulumix.Output[map[string]*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionPatchOutput struct{ *pulumi.OutputState } func (ControllerRevisionPatchOutput) ElementType() reflect.Type { @@ -200,6 +219,12 @@ func (o ControllerRevisionPatchOutput) ToControllerRevisionPatchOutputWithContex return o } +func (o ControllerRevisionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionPatch] { + return pulumix.Output[*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ControllerRevisionPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -239,6 +264,12 @@ func (o ControllerRevisionPatchArrayOutput) ToControllerRevisionPatchArrayOutput return o } +func (o ControllerRevisionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionPatch] { + return pulumix.Output[[]*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionPatchArrayOutput) Index(i pulumi.IntInput) ControllerRevisionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevisionPatch { return vs[0].([]*ControllerRevisionPatch)[vs[1].(int)] @@ -259,6 +290,12 @@ func (o ControllerRevisionPatchMapOutput) ToControllerRevisionPatchMapOutputWith return o } +func (o ControllerRevisionPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionPatch] { + return pulumix.Output[map[string]*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionPatchMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevisionPatch { return vs[0].(map[string]*ControllerRevisionPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/deployment.go b/sdk/go/kubernetes/apps/v1beta1/deployment.go index df25e37c70..1d0b674b40 100644 --- a/sdk/go/kubernetes/apps/v1beta1/deployment.go +++ b/sdk/go/kubernetes/apps/v1beta1/deployment.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Deployment enables declarative updates for Pods and ReplicaSets. @@ -151,6 +152,12 @@ func (i *Deployment) ToDeploymentOutputWithContext(ctx context.Context) Deployme return pulumi.ToOutputWithContext(ctx, i).(DeploymentOutput) } +func (i *Deployment) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: i.ToDeploymentOutputWithContext(ctx).OutputState, + } +} + // DeploymentArrayInput is an input type that accepts DeploymentArray and DeploymentArrayOutput values. // You can construct a concrete instance of `DeploymentArrayInput` via: // @@ -176,6 +183,12 @@ func (i DeploymentArray) ToDeploymentArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentArrayOutput) } +func (i DeploymentArray) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: i.ToDeploymentArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentMapInput is an input type that accepts DeploymentMap and DeploymentMapOutput values. // You can construct a concrete instance of `DeploymentMapInput` via: // @@ -201,6 +214,12 @@ func (i DeploymentMap) ToDeploymentMapOutputWithContext(ctx context.Context) Dep return pulumi.ToOutputWithContext(ctx, i).(DeploymentMapOutput) } +func (i DeploymentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: i.ToDeploymentMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentOutput struct{ *pulumi.OutputState } func (DeploymentOutput) ElementType() reflect.Type { @@ -215,6 +234,12 @@ func (o DeploymentOutput) ToDeploymentOutputWithContext(ctx context.Context) Dep return o } +func (o DeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Deployment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -254,6 +279,12 @@ func (o DeploymentArrayOutput) ToDeploymentArrayOutputWithContext(ctx context.Co return o } +func (o DeploymentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentArrayOutput) Index(i pulumi.IntInput) DeploymentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Deployment { return vs[0].([]*Deployment)[vs[1].(int)] @@ -274,6 +305,12 @@ func (o DeploymentMapOutput) ToDeploymentMapOutputWithContext(ctx context.Contex return o } +func (o DeploymentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentMapOutput) MapIndex(k pulumi.StringInput) DeploymentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Deployment { return vs[0].(map[string]*Deployment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/deploymentList.go b/sdk/go/kubernetes/apps/v1beta1/deploymentList.go index 3ab1bc9b4c..086e183098 100644 --- a/sdk/go/kubernetes/apps/v1beta1/deploymentList.go +++ b/sdk/go/kubernetes/apps/v1beta1/deploymentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DeploymentList is a list of Deployments. @@ -117,6 +118,12 @@ func (i *DeploymentList) ToDeploymentListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentListOutput) } +func (i *DeploymentList) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: i.ToDeploymentListOutputWithContext(ctx).OutputState, + } +} + // DeploymentListArrayInput is an input type that accepts DeploymentListArray and DeploymentListArrayOutput values. // You can construct a concrete instance of `DeploymentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DeploymentListArray) ToDeploymentListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentListArrayOutput) } +func (i DeploymentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: i.ToDeploymentListArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentListMapInput is an input type that accepts DeploymentListMap and DeploymentListMapOutput values. // You can construct a concrete instance of `DeploymentListMapInput` via: // @@ -167,6 +180,12 @@ func (i DeploymentListMap) ToDeploymentListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentListMapOutput) } +func (i DeploymentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: i.ToDeploymentListMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentListOutput struct{ *pulumi.OutputState } func (DeploymentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DeploymentListOutput) ToDeploymentListOutputWithContext(ctx context.Cont return o } +func (o DeploymentListOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DeploymentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DeploymentListArrayOutput) ToDeploymentListArrayOutputWithContext(ctx co return o } +func (o DeploymentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListArrayOutput) Index(i pulumi.IntInput) DeploymentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].([]*DeploymentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DeploymentListMapOutput) ToDeploymentListMapOutputWithContext(ctx contex return o } +func (o DeploymentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListMapOutput) MapIndex(k pulumi.StringInput) DeploymentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].(map[string]*DeploymentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/deploymentPatch.go b/sdk/go/kubernetes/apps/v1beta1/deploymentPatch.go index 5c259152cd..2f932ede02 100644 --- a/sdk/go/kubernetes/apps/v1beta1/deploymentPatch.go +++ b/sdk/go/kubernetes/apps/v1beta1/deploymentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -157,6 +158,12 @@ func (i *DeploymentPatch) ToDeploymentPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchOutput) } +func (i *DeploymentPatch) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchArrayInput is an input type that accepts DeploymentPatchArray and DeploymentPatchArrayOutput values. // You can construct a concrete instance of `DeploymentPatchArrayInput` via: // @@ -182,6 +189,12 @@ func (i DeploymentPatchArray) ToDeploymentPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchArrayOutput) } +func (i DeploymentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchMapInput is an input type that accepts DeploymentPatchMap and DeploymentPatchMapOutput values. // You can construct a concrete instance of `DeploymentPatchMapInput` via: // @@ -207,6 +220,12 @@ func (i DeploymentPatchMap) ToDeploymentPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchMapOutput) } +func (i DeploymentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentPatchOutput struct{ *pulumi.OutputState } func (DeploymentPatchOutput) ElementType() reflect.Type { @@ -221,6 +240,12 @@ func (o DeploymentPatchOutput) ToDeploymentPatchOutputWithContext(ctx context.Co return o } +func (o DeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DeploymentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -260,6 +285,12 @@ func (o DeploymentPatchArrayOutput) ToDeploymentPatchArrayOutputWithContext(ctx return o } +func (o DeploymentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchArrayOutput) Index(i pulumi.IntInput) DeploymentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].([]*DeploymentPatch)[vs[1].(int)] @@ -280,6 +311,12 @@ func (o DeploymentPatchMapOutput) ToDeploymentPatchMapOutputWithContext(ctx cont return o } +func (o DeploymentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchMapOutput) MapIndex(k pulumi.StringInput) DeploymentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].(map[string]*DeploymentPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/apps/v1beta1/pulumiTypes.go index 9593839032..2043875358 100644 --- a/sdk/go/kubernetes/apps/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/apps/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -66,6 +67,12 @@ func (i ControllerRevisionTypeArgs) ToControllerRevisionTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionTypeOutput) } +func (i ControllerRevisionTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionType] { + return pulumix.Output[ControllerRevisionType]{ + OutputState: i.ToControllerRevisionTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionTypeArrayInput is an input type that accepts ControllerRevisionTypeArray and ControllerRevisionTypeArrayOutput values. // You can construct a concrete instance of `ControllerRevisionTypeArrayInput` via: // @@ -91,6 +98,12 @@ func (i ControllerRevisionTypeArray) ToControllerRevisionTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionTypeArrayOutput) } +func (i ControllerRevisionTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ControllerRevisionType] { + return pulumix.Output[[]ControllerRevisionType]{ + OutputState: i.ToControllerRevisionTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. type ControllerRevisionTypeOutput struct{ *pulumi.OutputState } @@ -106,6 +119,12 @@ func (o ControllerRevisionTypeOutput) ToControllerRevisionTypeOutputWithContext( return o } +func (o ControllerRevisionTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionType] { + return pulumix.Output[ControllerRevisionType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -145,6 +164,12 @@ func (o ControllerRevisionTypeArrayOutput) ToControllerRevisionTypeArrayOutputWi return o } +func (o ControllerRevisionTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ControllerRevisionType] { + return pulumix.Output[[]ControllerRevisionType]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionTypeArrayOutput) Index(i pulumi.IntInput) ControllerRevisionTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ControllerRevisionType { return vs[0].([]ControllerRevisionType)[vs[1].(int)] @@ -198,6 +223,12 @@ func (i ControllerRevisionListTypeArgs) ToControllerRevisionListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListTypeOutput) } +func (i ControllerRevisionListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionListType] { + return pulumix.Output[ControllerRevisionListType]{ + OutputState: i.ToControllerRevisionListTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionList is a resource containing a list of ControllerRevision objects. type ControllerRevisionListTypeOutput struct{ *pulumi.OutputState } @@ -213,6 +244,12 @@ func (o ControllerRevisionListTypeOutput) ToControllerRevisionListTypeOutputWith return o } +func (o ControllerRevisionListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionListType] { + return pulumix.Output[ControllerRevisionListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -284,6 +321,12 @@ func (i ControllerRevisionPatchTypeArgs) ToControllerRevisionPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchTypeOutput) } +func (i ControllerRevisionPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionPatchType] { + return pulumix.Output[ControllerRevisionPatchType]{ + OutputState: i.ToControllerRevisionPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. type ControllerRevisionPatchTypeOutput struct{ *pulumi.OutputState } @@ -299,6 +342,12 @@ func (o ControllerRevisionPatchTypeOutput) ToControllerRevisionPatchTypeOutputWi return o } +func (o ControllerRevisionPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionPatchType] { + return pulumix.Output[ControllerRevisionPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -419,6 +468,12 @@ func (i DeploymentTypeArgs) ToDeploymentTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeOutput) } +func (i DeploymentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: i.ToDeploymentTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentTypeArrayInput is an input type that accepts DeploymentTypeArray and DeploymentTypeArrayOutput values. // You can construct a concrete instance of `DeploymentTypeArrayInput` via: // @@ -444,6 +499,12 @@ func (i DeploymentTypeArray) ToDeploymentTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeArrayOutput) } +func (i DeploymentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: i.ToDeploymentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -481,6 +542,12 @@ func (o DeploymentTypeOutput) ToDeploymentTypeOutputWithContext(ctx context.Cont return o } +func (o DeploymentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -520,6 +587,12 @@ func (o DeploymentTypeArrayOutput) ToDeploymentTypeArrayOutputWithContext(ctx co return o } +func (o DeploymentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: o.OutputState, + } +} + func (o DeploymentTypeArrayOutput) Index(i pulumi.IntInput) DeploymentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentType { return vs[0].([]DeploymentType)[vs[1].(int)] @@ -581,6 +654,12 @@ func (i DeploymentConditionArgs) ToDeploymentConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionOutput) } +func (i DeploymentConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: i.ToDeploymentConditionOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionArrayInput is an input type that accepts DeploymentConditionArray and DeploymentConditionArrayOutput values. // You can construct a concrete instance of `DeploymentConditionArrayInput` via: // @@ -606,6 +685,12 @@ func (i DeploymentConditionArray) ToDeploymentConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionArrayOutput) } +func (i DeploymentConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: i.ToDeploymentConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionOutput struct{ *pulumi.OutputState } @@ -621,6 +706,12 @@ func (o DeploymentConditionOutput) ToDeploymentConditionOutputWithContext(ctx co return o } +func (o DeploymentConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -665,6 +756,12 @@ func (o DeploymentConditionArrayOutput) ToDeploymentConditionArrayOutputWithCont return o } +func (o DeploymentConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionArrayOutput) Index(i pulumi.IntInput) DeploymentConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentCondition { return vs[0].([]DeploymentCondition)[vs[1].(int)] @@ -726,6 +823,12 @@ func (i DeploymentConditionPatchArgs) ToDeploymentConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchOutput) } +func (i DeploymentConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionPatchArrayInput is an input type that accepts DeploymentConditionPatchArray and DeploymentConditionPatchArrayOutput values. // You can construct a concrete instance of `DeploymentConditionPatchArrayInput` via: // @@ -751,6 +854,12 @@ func (i DeploymentConditionPatchArray) ToDeploymentConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchArrayOutput) } +func (i DeploymentConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionPatchOutput struct{ *pulumi.OutputState } @@ -766,6 +875,12 @@ func (o DeploymentConditionPatchOutput) ToDeploymentConditionPatchOutputWithCont return o } +func (o DeploymentConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -810,6 +925,12 @@ func (o DeploymentConditionPatchArrayOutput) ToDeploymentConditionPatchArrayOutp return o } +func (o DeploymentConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionPatchArrayOutput) Index(i pulumi.IntInput) DeploymentConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentConditionPatch { return vs[0].([]DeploymentConditionPatch)[vs[1].(int)] @@ -863,6 +984,12 @@ func (i DeploymentListTypeArgs) ToDeploymentListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentListTypeOutput) } +func (i DeploymentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: i.ToDeploymentListTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentList is a list of Deployments. type DeploymentListTypeOutput struct{ *pulumi.OutputState } @@ -878,6 +1005,12 @@ func (o DeploymentListTypeOutput) ToDeploymentListTypeOutputWithContext(ctx cont return o } +func (o DeploymentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -993,6 +1126,12 @@ func (i DeploymentPatchTypeArgs) ToDeploymentPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchTypeOutput) } +func (i DeploymentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: i.ToDeploymentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -1030,6 +1169,12 @@ func (o DeploymentPatchTypeOutput) ToDeploymentPatchTypeOutputWithContext(ctx co return o } +func (o DeploymentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1106,6 +1251,12 @@ func (i DeploymentRollbackArgs) ToDeploymentRollbackOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentRollbackOutput) } +func (i DeploymentRollbackArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollback] { + return pulumix.Output[DeploymentRollback]{ + OutputState: i.ToDeploymentRollbackOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. type DeploymentRollbackOutput struct{ *pulumi.OutputState } @@ -1121,6 +1272,12 @@ func (o DeploymentRollbackOutput) ToDeploymentRollbackOutputWithContext(ctx cont return o } +func (o DeploymentRollbackOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollback] { + return pulumix.Output[DeploymentRollback]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentRollbackOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentRollback) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1197,6 +1354,12 @@ func (i DeploymentRollbackPatchArgs) ToDeploymentRollbackPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DeploymentRollbackPatchOutput) } +func (i DeploymentRollbackPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollbackPatch] { + return pulumix.Output[DeploymentRollbackPatch]{ + OutputState: i.ToDeploymentRollbackPatchOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. type DeploymentRollbackPatchOutput struct{ *pulumi.OutputState } @@ -1212,6 +1375,12 @@ func (o DeploymentRollbackPatchOutput) ToDeploymentRollbackPatchOutputWithContex return o } +func (o DeploymentRollbackPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollbackPatch] { + return pulumix.Output[DeploymentRollbackPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentRollbackPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentRollbackPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1304,6 +1473,12 @@ func (i DeploymentSpecArgs) ToDeploymentSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecOutput) } +func (i DeploymentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: i.ToDeploymentSpecOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecArgs) ToDeploymentSpecPtrOutput() DeploymentSpecPtrOutput { return i.ToDeploymentSpecPtrOutputWithContext(context.Background()) } @@ -1345,6 +1520,12 @@ func (i *deploymentSpecPtrType) ToDeploymentSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPtrOutput) } +func (i *deploymentSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: i.ToDeploymentSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecOutput struct{ *pulumi.OutputState } @@ -1370,6 +1551,12 @@ func (o DeploymentSpecOutput) ToDeploymentSpecPtrOutputWithContext(ctx context.C }).(DeploymentSpecPtrOutput) } +func (o DeploymentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1429,6 +1616,12 @@ func (o DeploymentSpecPtrOutput) ToDeploymentSpecPtrOutputWithContext(ctx contex return o } +func (o DeploymentSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPtrOutput) Elem() DeploymentSpecOutput { return o.ApplyT(func(v *DeploymentSpec) DeploymentSpec { if v != nil { @@ -1596,6 +1789,12 @@ func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchOutput) } +func (i DeploymentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchPtrOutput() DeploymentSpecPatchPtrOutput { return i.ToDeploymentSpecPatchPtrOutputWithContext(context.Background()) } @@ -1637,6 +1836,12 @@ func (i *deploymentSpecPatchPtrType) ToDeploymentSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchPtrOutput) } +func (i *deploymentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecPatchOutput struct{ *pulumi.OutputState } @@ -1662,6 +1867,12 @@ func (o DeploymentSpecPatchOutput) ToDeploymentSpecPatchPtrOutputWithContext(ctx }).(DeploymentSpecPatchPtrOutput) } +func (o DeploymentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1721,6 +1932,12 @@ func (o DeploymentSpecPatchPtrOutput) ToDeploymentSpecPatchPtrOutputWithContext( return o } +func (o DeploymentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPatchPtrOutput) Elem() DeploymentSpecPatchOutput { return o.ApplyT(func(v *DeploymentSpecPatch) DeploymentSpecPatch { if v != nil { @@ -1884,6 +2101,12 @@ func (i DeploymentStatusArgs) ToDeploymentStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusOutput) } +func (i DeploymentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: i.ToDeploymentStatusOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusArgs) ToDeploymentStatusPtrOutput() DeploymentStatusPtrOutput { return i.ToDeploymentStatusPtrOutputWithContext(context.Background()) } @@ -1925,6 +2148,12 @@ func (i *deploymentStatusPtrType) ToDeploymentStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPtrOutput) } +func (i *deploymentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: i.ToDeploymentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusOutput struct{ *pulumi.OutputState } @@ -1950,6 +2179,12 @@ func (o DeploymentStatusOutput) ToDeploymentStatusPtrOutputWithContext(ctx conte }).(DeploymentStatusPtrOutput) } +func (o DeploymentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -2004,6 +2239,12 @@ func (o DeploymentStatusPtrOutput) ToDeploymentStatusPtrOutputWithContext(ctx co return o } +func (o DeploymentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPtrOutput) Elem() DeploymentStatusOutput { return o.ApplyT(func(v *DeploymentStatus) DeploymentStatus { if v != nil { @@ -2157,6 +2398,12 @@ func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchOutput) } +func (i DeploymentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchPtrOutput() DeploymentStatusPatchPtrOutput { return i.ToDeploymentStatusPatchPtrOutputWithContext(context.Background()) } @@ -2198,6 +2445,12 @@ func (i *deploymentStatusPatchPtrType) ToDeploymentStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchPtrOutput) } +func (i *deploymentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusPatchOutput struct{ *pulumi.OutputState } @@ -2223,6 +2476,12 @@ func (o DeploymentStatusPatchOutput) ToDeploymentStatusPatchPtrOutputWithContext }).(DeploymentStatusPatchPtrOutput) } +func (o DeploymentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -2277,6 +2536,12 @@ func (o DeploymentStatusPatchPtrOutput) ToDeploymentStatusPatchPtrOutputWithCont return o } +func (o DeploymentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPatchPtrOutput) Elem() DeploymentStatusPatchOutput { return o.ApplyT(func(v *DeploymentStatusPatch) DeploymentStatusPatch { if v != nil { @@ -2406,6 +2671,12 @@ func (i DeploymentStrategyArgs) ToDeploymentStrategyOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyOutput) } +func (i DeploymentStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyArgs) ToDeploymentStrategyPtrOutput() DeploymentStrategyPtrOutput { return i.ToDeploymentStrategyPtrOutputWithContext(context.Background()) } @@ -2447,6 +2718,12 @@ func (i *deploymentStrategyPtrType) ToDeploymentStrategyPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPtrOutput) } +func (i *deploymentStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyOutput struct{ *pulumi.OutputState } @@ -2472,6 +2749,12 @@ func (o DeploymentStrategyOutput) ToDeploymentStrategyPtrOutputWithContext(ctx c }).(DeploymentStrategyPtrOutput) } +func (o DeploymentStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyOutput) RollingUpdate() RollingUpdateDeploymentPtrOutput { return o.ApplyT(func(v DeploymentStrategy) *RollingUpdateDeployment { return v.RollingUpdate }).(RollingUpdateDeploymentPtrOutput) @@ -2496,6 +2779,12 @@ func (o DeploymentStrategyPtrOutput) ToDeploymentStrategyPtrOutputWithContext(ct return o } +func (o DeploymentStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPtrOutput) Elem() DeploymentStrategyOutput { return o.ApplyT(func(v *DeploymentStrategy) DeploymentStrategy { if v != nil { @@ -2565,6 +2854,12 @@ func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchOutput) } +func (i DeploymentStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchPtrOutput() DeploymentStrategyPatchPtrOutput { return i.ToDeploymentStrategyPatchPtrOutputWithContext(context.Background()) } @@ -2606,6 +2901,12 @@ func (i *deploymentStrategyPatchPtrType) ToDeploymentStrategyPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchPtrOutput) } +func (i *deploymentStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyPatchOutput struct{ *pulumi.OutputState } @@ -2631,6 +2932,12 @@ func (o DeploymentStrategyPatchOutput) ToDeploymentStrategyPatchPtrOutputWithCon }).(DeploymentStrategyPatchPtrOutput) } +func (o DeploymentStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyPatchOutput) RollingUpdate() RollingUpdateDeploymentPatchPtrOutput { return o.ApplyT(func(v DeploymentStrategyPatch) *RollingUpdateDeploymentPatch { return v.RollingUpdate }).(RollingUpdateDeploymentPatchPtrOutput) @@ -2655,6 +2962,12 @@ func (o DeploymentStrategyPatchPtrOutput) ToDeploymentStrategyPatchPtrOutputWith return o } +func (o DeploymentStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPatchPtrOutput) Elem() DeploymentStrategyPatchOutput { return o.ApplyT(func(v *DeploymentStrategyPatch) DeploymentStrategyPatch { if v != nil { @@ -2720,6 +3033,12 @@ func (i RollbackConfigArgs) ToRollbackConfigOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigOutput) } +func (i RollbackConfigArgs) ToOutput(ctx context.Context) pulumix.Output[RollbackConfig] { + return pulumix.Output[RollbackConfig]{ + OutputState: i.ToRollbackConfigOutputWithContext(ctx).OutputState, + } +} + func (i RollbackConfigArgs) ToRollbackConfigPtrOutput() RollbackConfigPtrOutput { return i.ToRollbackConfigPtrOutputWithContext(context.Background()) } @@ -2761,6 +3080,12 @@ func (i *rollbackConfigPtrType) ToRollbackConfigPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigPtrOutput) } +func (i *rollbackConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfig] { + return pulumix.Output[*RollbackConfig]{ + OutputState: i.ToRollbackConfigPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. type RollbackConfigOutput struct{ *pulumi.OutputState } @@ -2786,6 +3111,12 @@ func (o RollbackConfigOutput) ToRollbackConfigPtrOutputWithContext(ctx context.C }).(RollbackConfigPtrOutput) } +func (o RollbackConfigOutput) ToOutput(ctx context.Context) pulumix.Output[RollbackConfig] { + return pulumix.Output[RollbackConfig]{ + OutputState: o.OutputState, + } +} + // The revision to rollback to. If set to 0, rollback to the last revision. func (o RollbackConfigOutput) Revision() pulumi.IntPtrOutput { return o.ApplyT(func(v RollbackConfig) *int { return v.Revision }).(pulumi.IntPtrOutput) @@ -2805,6 +3136,12 @@ func (o RollbackConfigPtrOutput) ToRollbackConfigPtrOutputWithContext(ctx contex return o } +func (o RollbackConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfig] { + return pulumix.Output[*RollbackConfig]{ + OutputState: o.OutputState, + } +} + func (o RollbackConfigPtrOutput) Elem() RollbackConfigOutput { return o.ApplyT(func(v *RollbackConfig) RollbackConfig { if v != nil { @@ -2860,6 +3197,12 @@ func (i RollbackConfigPatchArgs) ToRollbackConfigPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigPatchOutput) } +func (i RollbackConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollbackConfigPatch] { + return pulumix.Output[RollbackConfigPatch]{ + OutputState: i.ToRollbackConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollbackConfigPatchArgs) ToRollbackConfigPatchPtrOutput() RollbackConfigPatchPtrOutput { return i.ToRollbackConfigPatchPtrOutputWithContext(context.Background()) } @@ -2901,6 +3244,12 @@ func (i *rollbackConfigPatchPtrType) ToRollbackConfigPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigPatchPtrOutput) } +func (i *rollbackConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfigPatch] { + return pulumix.Output[*RollbackConfigPatch]{ + OutputState: i.ToRollbackConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. type RollbackConfigPatchOutput struct{ *pulumi.OutputState } @@ -2926,6 +3275,12 @@ func (o RollbackConfigPatchOutput) ToRollbackConfigPatchPtrOutputWithContext(ctx }).(RollbackConfigPatchPtrOutput) } +func (o RollbackConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollbackConfigPatch] { + return pulumix.Output[RollbackConfigPatch]{ + OutputState: o.OutputState, + } +} + // The revision to rollback to. If set to 0, rollback to the last revision. func (o RollbackConfigPatchOutput) Revision() pulumi.IntPtrOutput { return o.ApplyT(func(v RollbackConfigPatch) *int { return v.Revision }).(pulumi.IntPtrOutput) @@ -2945,6 +3300,12 @@ func (o RollbackConfigPatchPtrOutput) ToRollbackConfigPatchPtrOutputWithContext( return o } +func (o RollbackConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfigPatch] { + return pulumix.Output[*RollbackConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o RollbackConfigPatchPtrOutput) Elem() RollbackConfigPatchOutput { return o.ApplyT(func(v *RollbackConfigPatch) RollbackConfigPatch { if v != nil { @@ -3004,6 +3365,12 @@ func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentOutput) } +func (i RollingUpdateDeploymentArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentPtrOutput() RollingUpdateDeploymentPtrOutput { return i.ToRollingUpdateDeploymentPtrOutputWithContext(context.Background()) } @@ -3045,6 +3412,12 @@ func (i *rollingUpdateDeploymentPtrType) ToRollingUpdateDeploymentPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPtrOutput) } +func (i *rollingUpdateDeploymentPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentOutput struct{ *pulumi.OutputState } @@ -3070,6 +3443,12 @@ func (o RollingUpdateDeploymentOutput) ToRollingUpdateDeploymentPtrOutputWithCon }).(RollingUpdateDeploymentPtrOutput) } +func (o RollingUpdateDeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeployment) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -3094,6 +3473,12 @@ func (o RollingUpdateDeploymentPtrOutput) ToRollingUpdateDeploymentPtrOutputWith return o } +func (o RollingUpdateDeploymentPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPtrOutput) Elem() RollingUpdateDeploymentOutput { return o.ApplyT(func(v *RollingUpdateDeployment) RollingUpdateDeployment { if v != nil { @@ -3163,6 +3548,12 @@ func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchOutput) } +func (i RollingUpdateDeploymentPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchPtrOutput() RollingUpdateDeploymentPatchPtrOutput { return i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(context.Background()) } @@ -3204,6 +3595,12 @@ func (i *rollingUpdateDeploymentPatchPtrType) ToRollingUpdateDeploymentPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchPtrOutput) } +func (i *rollingUpdateDeploymentPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentPatchOutput struct{ *pulumi.OutputState } @@ -3229,6 +3626,12 @@ func (o RollingUpdateDeploymentPatchOutput) ToRollingUpdateDeploymentPatchPtrOut }).(RollingUpdateDeploymentPatchPtrOutput) } +func (o RollingUpdateDeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentPatchOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeploymentPatch) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -3253,6 +3656,12 @@ func (o RollingUpdateDeploymentPatchPtrOutput) ToRollingUpdateDeploymentPatchPtr return o } +func (o RollingUpdateDeploymentPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPatchPtrOutput) Elem() RollingUpdateDeploymentPatchOutput { return o.ApplyT(func(v *RollingUpdateDeploymentPatch) RollingUpdateDeploymentPatch { if v != nil { @@ -3318,6 +3727,12 @@ func (i RollingUpdateStatefulSetStrategyArgs) ToRollingUpdateStatefulSetStrategy return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyOutput) } +func (i RollingUpdateStatefulSetStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategy] { + return pulumix.Output[RollingUpdateStatefulSetStrategy]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateStatefulSetStrategyArgs) ToRollingUpdateStatefulSetStrategyPtrOutput() RollingUpdateStatefulSetStrategyPtrOutput { return i.ToRollingUpdateStatefulSetStrategyPtrOutputWithContext(context.Background()) } @@ -3359,6 +3774,12 @@ func (i *rollingUpdateStatefulSetStrategyPtrType) ToRollingUpdateStatefulSetStra return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPtrOutput) } +func (i *rollingUpdateStatefulSetStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategy] { + return pulumix.Output[*RollingUpdateStatefulSetStrategy]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. type RollingUpdateStatefulSetStrategyOutput struct{ *pulumi.OutputState } @@ -3384,6 +3805,12 @@ func (o RollingUpdateStatefulSetStrategyOutput) ToRollingUpdateStatefulSetStrate }).(RollingUpdateStatefulSetStrategyPtrOutput) } +func (o RollingUpdateStatefulSetStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategy] { + return pulumix.Output[RollingUpdateStatefulSetStrategy]{ + OutputState: o.OutputState, + } +} + // Partition indicates the ordinal at which the StatefulSet should be partitioned. func (o RollingUpdateStatefulSetStrategyOutput) Partition() pulumi.IntPtrOutput { return o.ApplyT(func(v RollingUpdateStatefulSetStrategy) *int { return v.Partition }).(pulumi.IntPtrOutput) @@ -3403,6 +3830,12 @@ func (o RollingUpdateStatefulSetStrategyPtrOutput) ToRollingUpdateStatefulSetStr return o } +func (o RollingUpdateStatefulSetStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategy] { + return pulumix.Output[*RollingUpdateStatefulSetStrategy]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateStatefulSetStrategyPtrOutput) Elem() RollingUpdateStatefulSetStrategyOutput { return o.ApplyT(func(v *RollingUpdateStatefulSetStrategy) RollingUpdateStatefulSetStrategy { if v != nil { @@ -3458,6 +3891,12 @@ func (i RollingUpdateStatefulSetStrategyPatchArgs) ToRollingUpdateStatefulSetStr return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPatchOutput) } +func (i RollingUpdateStatefulSetStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[RollingUpdateStatefulSetStrategyPatch]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateStatefulSetStrategyPatchArgs) ToRollingUpdateStatefulSetStrategyPatchPtrOutput() RollingUpdateStatefulSetStrategyPatchPtrOutput { return i.ToRollingUpdateStatefulSetStrategyPatchPtrOutputWithContext(context.Background()) } @@ -3499,6 +3938,12 @@ func (i *rollingUpdateStatefulSetStrategyPatchPtrType) ToRollingUpdateStatefulSe return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPatchPtrOutput) } +func (i *rollingUpdateStatefulSetStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[*RollingUpdateStatefulSetStrategyPatch]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. type RollingUpdateStatefulSetStrategyPatchOutput struct{ *pulumi.OutputState } @@ -3524,6 +3969,12 @@ func (o RollingUpdateStatefulSetStrategyPatchOutput) ToRollingUpdateStatefulSetS }).(RollingUpdateStatefulSetStrategyPatchPtrOutput) } +func (o RollingUpdateStatefulSetStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[RollingUpdateStatefulSetStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Partition indicates the ordinal at which the StatefulSet should be partitioned. func (o RollingUpdateStatefulSetStrategyPatchOutput) Partition() pulumi.IntPtrOutput { return o.ApplyT(func(v RollingUpdateStatefulSetStrategyPatch) *int { return v.Partition }).(pulumi.IntPtrOutput) @@ -3543,6 +3994,12 @@ func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) ToRollingUpdateStatefulS return o } +func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[*RollingUpdateStatefulSetStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) Elem() RollingUpdateStatefulSetStrategyPatchOutput { return o.ApplyT(func(v *RollingUpdateStatefulSetStrategyPatch) RollingUpdateStatefulSetStrategyPatch { if v != nil { @@ -3614,6 +4071,12 @@ func (i ScaleArgs) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return pulumi.ToOutputWithContext(ctx, i).(ScaleOutput) } +func (i ScaleArgs) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: i.ToScaleOutputWithContext(ctx).OutputState, + } +} + // Scale represents a scaling request for a resource. type ScaleOutput struct{ *pulumi.OutputState } @@ -3629,6 +4092,12 @@ func (o ScaleOutput) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return o } +func (o ScaleOutput) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScaleOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Scale) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3705,6 +4174,12 @@ func (i ScalePatchArgs) ToScalePatchOutputWithContext(ctx context.Context) Scale return pulumi.ToOutputWithContext(ctx, i).(ScalePatchOutput) } +func (i ScalePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: i.ToScalePatchOutputWithContext(ctx).OutputState, + } +} + // Scale represents a scaling request for a resource. type ScalePatchOutput struct{ *pulumi.OutputState } @@ -3720,6 +4195,12 @@ func (o ScalePatchOutput) ToScalePatchOutputWithContext(ctx context.Context) Sca return o } +func (o ScalePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScalePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ScalePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3780,6 +4261,12 @@ func (i ScaleSpecArgs) ToScaleSpecOutputWithContext(ctx context.Context) ScaleSp return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecOutput) } +func (i ScaleSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: i.ToScaleSpecOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecArgs) ToScaleSpecPtrOutput() ScaleSpecPtrOutput { return i.ToScaleSpecPtrOutputWithContext(context.Background()) } @@ -3821,6 +4308,12 @@ func (i *scaleSpecPtrType) ToScaleSpecPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPtrOutput) } +func (i *scaleSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: i.ToScaleSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleSpec describes the attributes of a scale subresource type ScaleSpecOutput struct{ *pulumi.OutputState } @@ -3846,6 +4339,12 @@ func (o ScaleSpecOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) Sc }).(ScaleSpecPtrOutput) } +func (o ScaleSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: o.OutputState, + } +} + // desired number of instances for the scaled object. func (o ScaleSpecOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpec) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -3865,6 +4364,12 @@ func (o ScaleSpecPtrOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) return o } +func (o ScaleSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPtrOutput) Elem() ScaleSpecOutput { return o.ApplyT(func(v *ScaleSpec) ScaleSpec { if v != nil { @@ -3920,6 +4425,12 @@ func (i ScaleSpecPatchArgs) ToScaleSpecPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchOutput) } +func (i ScaleSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecPatchArgs) ToScaleSpecPatchPtrOutput() ScaleSpecPatchPtrOutput { return i.ToScaleSpecPatchPtrOutputWithContext(context.Background()) } @@ -3961,6 +4472,12 @@ func (i *scaleSpecPatchPtrType) ToScaleSpecPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchPtrOutput) } +func (i *scaleSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleSpec describes the attributes of a scale subresource type ScaleSpecPatchOutput struct{ *pulumi.OutputState } @@ -3986,6 +4503,12 @@ func (o ScaleSpecPatchOutput) ToScaleSpecPatchPtrOutputWithContext(ctx context.C }).(ScaleSpecPatchPtrOutput) } +func (o ScaleSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + // desired number of instances for the scaled object. func (o ScaleSpecPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpecPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -4005,6 +4528,12 @@ func (o ScaleSpecPatchPtrOutput) ToScaleSpecPatchPtrOutputWithContext(ctx contex return o } +func (o ScaleSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPatchPtrOutput) Elem() ScaleSpecPatchOutput { return o.ApplyT(func(v *ScaleSpecPatch) ScaleSpecPatch { if v != nil { @@ -4068,6 +4597,12 @@ func (i ScaleStatusArgs) ToScaleStatusOutputWithContext(ctx context.Context) Sca return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusOutput) } +func (i ScaleStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: i.ToScaleStatusOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusArgs) ToScaleStatusPtrOutput() ScaleStatusPtrOutput { return i.ToScaleStatusPtrOutputWithContext(context.Background()) } @@ -4109,6 +4644,12 @@ func (i *scaleStatusPtrType) ToScaleStatusPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPtrOutput) } +func (i *scaleStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: i.ToScaleStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleStatus represents the current status of a scale subresource. type ScaleStatusOutput struct{ *pulumi.OutputState } @@ -4134,6 +4675,12 @@ func (o ScaleStatusOutput) ToScaleStatusPtrOutputWithContext(ctx context.Context }).(ScaleStatusPtrOutput) } +func (o ScaleStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: o.OutputState, + } +} + // actual number of observed instances of the scaled object. func (o ScaleStatusOutput) Replicas() pulumi.IntOutput { return o.ApplyT(func(v ScaleStatus) int { return v.Replicas }).(pulumi.IntOutput) @@ -4163,6 +4710,12 @@ func (o ScaleStatusPtrOutput) ToScaleStatusPtrOutputWithContext(ctx context.Cont return o } +func (o ScaleStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPtrOutput) Elem() ScaleStatusOutput { return o.ApplyT(func(v *ScaleStatus) ScaleStatus { if v != nil { @@ -4246,6 +4799,12 @@ func (i ScaleStatusPatchArgs) ToScaleStatusPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchOutput) } +func (i ScaleStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusPatchArgs) ToScaleStatusPatchPtrOutput() ScaleStatusPatchPtrOutput { return i.ToScaleStatusPatchPtrOutputWithContext(context.Background()) } @@ -4287,6 +4846,12 @@ func (i *scaleStatusPatchPtrType) ToScaleStatusPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchPtrOutput) } +func (i *scaleStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleStatus represents the current status of a scale subresource. type ScaleStatusPatchOutput struct{ *pulumi.OutputState } @@ -4312,6 +4877,12 @@ func (o ScaleStatusPatchOutput) ToScaleStatusPatchPtrOutputWithContext(ctx conte }).(ScaleStatusPatchPtrOutput) } +func (o ScaleStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + // actual number of observed instances of the scaled object. func (o ScaleStatusPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleStatusPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -4341,6 +4912,12 @@ func (o ScaleStatusPatchPtrOutput) ToScaleStatusPatchPtrOutputWithContext(ctx co return o } +func (o ScaleStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPatchPtrOutput) Elem() ScaleStatusPatchOutput { return o.ApplyT(func(v *ScaleStatusPatch) ScaleStatusPatch { if v != nil { @@ -4462,6 +5039,12 @@ func (i StatefulSetTypeArgs) ToStatefulSetTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetTypeOutput) } +func (i StatefulSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetType] { + return pulumix.Output[StatefulSetType]{ + OutputState: i.ToStatefulSetTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSetTypeArrayInput is an input type that accepts StatefulSetTypeArray and StatefulSetTypeArrayOutput values. // You can construct a concrete instance of `StatefulSetTypeArrayInput` via: // @@ -4487,6 +5070,12 @@ func (i StatefulSetTypeArray) ToStatefulSetTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetTypeArrayOutput) } +func (i StatefulSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetType] { + return pulumix.Output[[]StatefulSetType]{ + OutputState: i.ToStatefulSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSet represents a set of pods with consistent identities. Identities are defined as: // - Network: A single stable DNS and hostname. // - Storage: As many VolumeClaims as requested. @@ -4518,6 +5107,12 @@ func (o StatefulSetTypeOutput) ToStatefulSetTypeOutputWithContext(ctx context.Co return o } +func (o StatefulSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetType] { + return pulumix.Output[StatefulSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4556,6 +5151,12 @@ func (o StatefulSetTypeArrayOutput) ToStatefulSetTypeArrayOutputWithContext(ctx return o } +func (o StatefulSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetType] { + return pulumix.Output[[]StatefulSetType]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetTypeArrayOutput) Index(i pulumi.IntInput) StatefulSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetType { return vs[0].([]StatefulSetType)[vs[1].(int)] @@ -4613,6 +5214,12 @@ func (i StatefulSetConditionArgs) ToStatefulSetConditionOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionOutput) } +func (i StatefulSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetCondition] { + return pulumix.Output[StatefulSetCondition]{ + OutputState: i.ToStatefulSetConditionOutputWithContext(ctx).OutputState, + } +} + // StatefulSetConditionArrayInput is an input type that accepts StatefulSetConditionArray and StatefulSetConditionArrayOutput values. // You can construct a concrete instance of `StatefulSetConditionArrayInput` via: // @@ -4638,6 +5245,12 @@ func (i StatefulSetConditionArray) ToStatefulSetConditionArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionArrayOutput) } +func (i StatefulSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetCondition] { + return pulumix.Output[[]StatefulSetCondition]{ + OutputState: i.ToStatefulSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetCondition describes the state of a statefulset at a certain point. type StatefulSetConditionOutput struct{ *pulumi.OutputState } @@ -4653,6 +5266,12 @@ func (o StatefulSetConditionOutput) ToStatefulSetConditionOutputWithContext(ctx return o } +func (o StatefulSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetCondition] { + return pulumix.Output[StatefulSetCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o StatefulSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -4692,6 +5311,12 @@ func (o StatefulSetConditionArrayOutput) ToStatefulSetConditionArrayOutputWithCo return o } +func (o StatefulSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetCondition] { + return pulumix.Output[[]StatefulSetCondition]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetConditionArrayOutput) Index(i pulumi.IntInput) StatefulSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetCondition { return vs[0].([]StatefulSetCondition)[vs[1].(int)] @@ -4749,6 +5374,12 @@ func (i StatefulSetConditionPatchArgs) ToStatefulSetConditionPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionPatchOutput) } +func (i StatefulSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetConditionPatch] { + return pulumix.Output[StatefulSetConditionPatch]{ + OutputState: i.ToStatefulSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // StatefulSetConditionPatchArrayInput is an input type that accepts StatefulSetConditionPatchArray and StatefulSetConditionPatchArrayOutput values. // You can construct a concrete instance of `StatefulSetConditionPatchArrayInput` via: // @@ -4774,6 +5405,12 @@ func (i StatefulSetConditionPatchArray) ToStatefulSetConditionPatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionPatchArrayOutput) } +func (i StatefulSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetConditionPatch] { + return pulumix.Output[[]StatefulSetConditionPatch]{ + OutputState: i.ToStatefulSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetCondition describes the state of a statefulset at a certain point. type StatefulSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -4789,6 +5426,12 @@ func (o StatefulSetConditionPatchOutput) ToStatefulSetConditionPatchOutputWithCo return o } +func (o StatefulSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetConditionPatch] { + return pulumix.Output[StatefulSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o StatefulSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -4828,6 +5471,12 @@ func (o StatefulSetConditionPatchArrayOutput) ToStatefulSetConditionPatchArrayOu return o } +func (o StatefulSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetConditionPatch] { + return pulumix.Output[[]StatefulSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetConditionPatchArrayOutput) Index(i pulumi.IntInput) StatefulSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetConditionPatch { return vs[0].([]StatefulSetConditionPatch)[vs[1].(int)] @@ -4877,6 +5526,12 @@ func (i StatefulSetListTypeArgs) ToStatefulSetListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListTypeOutput) } +func (i StatefulSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetListType] { + return pulumix.Output[StatefulSetListType]{ + OutputState: i.ToStatefulSetListTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSetList is a collection of StatefulSets. type StatefulSetListTypeOutput struct{ *pulumi.OutputState } @@ -4892,6 +5547,12 @@ func (o StatefulSetListTypeOutput) ToStatefulSetListTypeOutputWithContext(ctx co return o } +func (o StatefulSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetListType] { + return pulumix.Output[StatefulSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4991,6 +5652,12 @@ func (i StatefulSetPatchTypeArgs) ToStatefulSetPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchTypeOutput) } +func (i StatefulSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPatchType] { + return pulumix.Output[StatefulSetPatchType]{ + OutputState: i.ToStatefulSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSet represents a set of pods with consistent identities. Identities are defined as: // - Network: A single stable DNS and hostname. // - Storage: As many VolumeClaims as requested. @@ -5022,6 +5689,12 @@ func (o StatefulSetPatchTypeOutput) ToStatefulSetPatchTypeOutputWithContext(ctx return o } +func (o StatefulSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPatchType] { + return pulumix.Output[StatefulSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5109,6 +5782,12 @@ func (i StatefulSetSpecArgs) ToStatefulSetSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecOutput) } +func (i StatefulSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpec] { + return pulumix.Output[StatefulSetSpec]{ + OutputState: i.ToStatefulSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetSpecArgs) ToStatefulSetSpecPtrOutput() StatefulSetSpecPtrOutput { return i.ToStatefulSetSpecPtrOutputWithContext(context.Background()) } @@ -5150,6 +5829,12 @@ func (i *statefulSetSpecPtrType) ToStatefulSetSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPtrOutput) } +func (i *statefulSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpec] { + return pulumix.Output[*StatefulSetSpec]{ + OutputState: i.ToStatefulSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpecOutput struct{ *pulumi.OutputState } @@ -5175,6 +5860,12 @@ func (o StatefulSetSpecOutput) ToStatefulSetSpecPtrOutputWithContext(ctx context }).(StatefulSetSpecPtrOutput) } +func (o StatefulSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpec] { + return pulumix.Output[StatefulSetSpec]{ + OutputState: o.OutputState, + } +} + // podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. func (o StatefulSetSpecOutput) PodManagementPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetSpec) *string { return v.PodManagementPolicy }).(pulumi.StringPtrOutput) @@ -5229,6 +5920,12 @@ func (o StatefulSetSpecPtrOutput) ToStatefulSetSpecPtrOutputWithContext(ctx cont return o } +func (o StatefulSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpec] { + return pulumix.Output[*StatefulSetSpec]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetSpecPtrOutput) Elem() StatefulSetSpecOutput { return o.ApplyT(func(v *StatefulSetSpec) StatefulSetSpec { if v != nil { @@ -5382,6 +6079,12 @@ func (i StatefulSetSpecPatchArgs) ToStatefulSetSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPatchOutput) } +func (i StatefulSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpecPatch] { + return pulumix.Output[StatefulSetSpecPatch]{ + OutputState: i.ToStatefulSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetSpecPatchArgs) ToStatefulSetSpecPatchPtrOutput() StatefulSetSpecPatchPtrOutput { return i.ToStatefulSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -5423,6 +6126,12 @@ func (i *statefulSetSpecPatchPtrType) ToStatefulSetSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPatchPtrOutput) } +func (i *statefulSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpecPatch] { + return pulumix.Output[*StatefulSetSpecPatch]{ + OutputState: i.ToStatefulSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -5448,6 +6157,12 @@ func (o StatefulSetSpecPatchOutput) ToStatefulSetSpecPatchPtrOutputWithContext(c }).(StatefulSetSpecPatchPtrOutput) } +func (o StatefulSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpecPatch] { + return pulumix.Output[StatefulSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. func (o StatefulSetSpecPatchOutput) PodManagementPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetSpecPatch) *string { return v.PodManagementPolicy }).(pulumi.StringPtrOutput) @@ -5502,6 +6217,12 @@ func (o StatefulSetSpecPatchPtrOutput) ToStatefulSetSpecPatchPtrOutputWithContex return o } +func (o StatefulSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpecPatch] { + return pulumix.Output[*StatefulSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetSpecPatchPtrOutput) Elem() StatefulSetSpecPatchOutput { return o.ApplyT(func(v *StatefulSetSpecPatch) StatefulSetSpecPatch { if v != nil { @@ -5659,6 +6380,12 @@ func (i StatefulSetStatusArgs) ToStatefulSetStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusOutput) } +func (i StatefulSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatus] { + return pulumix.Output[StatefulSetStatus]{ + OutputState: i.ToStatefulSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetStatusArgs) ToStatefulSetStatusPtrOutput() StatefulSetStatusPtrOutput { return i.ToStatefulSetStatusPtrOutputWithContext(context.Background()) } @@ -5700,6 +6427,12 @@ func (i *statefulSetStatusPtrType) ToStatefulSetStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPtrOutput) } +func (i *statefulSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatus] { + return pulumix.Output[*StatefulSetStatus]{ + OutputState: i.ToStatefulSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetStatus represents the current state of a StatefulSet. type StatefulSetStatusOutput struct{ *pulumi.OutputState } @@ -5725,6 +6458,12 @@ func (o StatefulSetStatusOutput) ToStatefulSetStatusPtrOutputWithContext(ctx con }).(StatefulSetStatusPtrOutput) } +func (o StatefulSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatus] { + return pulumix.Output[StatefulSetStatus]{ + OutputState: o.OutputState, + } +} + // collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o StatefulSetStatusOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetStatus) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -5784,6 +6523,12 @@ func (o StatefulSetStatusPtrOutput) ToStatefulSetStatusPtrOutputWithContext(ctx return o } +func (o StatefulSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatus] { + return pulumix.Output[*StatefulSetStatus]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetStatusPtrOutput) Elem() StatefulSetStatusOutput { return o.ApplyT(func(v *StatefulSetStatus) StatefulSetStatus { if v != nil { @@ -5951,6 +6696,12 @@ func (i StatefulSetStatusPatchArgs) ToStatefulSetStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPatchOutput) } +func (i StatefulSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatusPatch] { + return pulumix.Output[StatefulSetStatusPatch]{ + OutputState: i.ToStatefulSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetStatusPatchArgs) ToStatefulSetStatusPatchPtrOutput() StatefulSetStatusPatchPtrOutput { return i.ToStatefulSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -5992,6 +6743,12 @@ func (i *statefulSetStatusPatchPtrType) ToStatefulSetStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPatchPtrOutput) } +func (i *statefulSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatusPatch] { + return pulumix.Output[*StatefulSetStatusPatch]{ + OutputState: i.ToStatefulSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetStatus represents the current state of a StatefulSet. type StatefulSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -6017,6 +6774,12 @@ func (o StatefulSetStatusPatchOutput) ToStatefulSetStatusPatchPtrOutputWithConte }).(StatefulSetStatusPatchPtrOutput) } +func (o StatefulSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatusPatch] { + return pulumix.Output[StatefulSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o StatefulSetStatusPatchOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetStatusPatch) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -6076,6 +6839,12 @@ func (o StatefulSetStatusPatchPtrOutput) ToStatefulSetStatusPatchPtrOutputWithCo return o } +func (o StatefulSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatusPatch] { + return pulumix.Output[*StatefulSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetStatusPatchPtrOutput) Elem() StatefulSetStatusPatchOutput { return o.ApplyT(func(v *StatefulSetStatusPatch) StatefulSetStatusPatch { if v != nil { @@ -6215,6 +6984,12 @@ func (i StatefulSetUpdateStrategyArgs) ToStatefulSetUpdateStrategyOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyOutput) } +func (i StatefulSetUpdateStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategy] { + return pulumix.Output[StatefulSetUpdateStrategy]{ + OutputState: i.ToStatefulSetUpdateStrategyOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetUpdateStrategyArgs) ToStatefulSetUpdateStrategyPtrOutput() StatefulSetUpdateStrategyPtrOutput { return i.ToStatefulSetUpdateStrategyPtrOutputWithContext(context.Background()) } @@ -6256,6 +7031,12 @@ func (i *statefulSetUpdateStrategyPtrType) ToStatefulSetUpdateStrategyPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPtrOutput) } +func (i *statefulSetUpdateStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategy] { + return pulumix.Output[*StatefulSetUpdateStrategy]{ + OutputState: i.ToStatefulSetUpdateStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. type StatefulSetUpdateStrategyOutput struct{ *pulumi.OutputState } @@ -6281,6 +7062,12 @@ func (o StatefulSetUpdateStrategyOutput) ToStatefulSetUpdateStrategyPtrOutputWit }).(StatefulSetUpdateStrategyPtrOutput) } +func (o StatefulSetUpdateStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategy] { + return pulumix.Output[StatefulSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. func (o StatefulSetUpdateStrategyOutput) RollingUpdate() RollingUpdateStatefulSetStrategyPtrOutput { return o.ApplyT(func(v StatefulSetUpdateStrategy) *RollingUpdateStatefulSetStrategy { return v.RollingUpdate }).(RollingUpdateStatefulSetStrategyPtrOutput) @@ -6305,6 +7092,12 @@ func (o StatefulSetUpdateStrategyPtrOutput) ToStatefulSetUpdateStrategyPtrOutput return o } +func (o StatefulSetUpdateStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategy] { + return pulumix.Output[*StatefulSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetUpdateStrategyPtrOutput) Elem() StatefulSetUpdateStrategyOutput { return o.ApplyT(func(v *StatefulSetUpdateStrategy) StatefulSetUpdateStrategy { if v != nil { @@ -6374,6 +7167,12 @@ func (i StatefulSetUpdateStrategyPatchArgs) ToStatefulSetUpdateStrategyPatchOutp return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPatchOutput) } +func (i StatefulSetUpdateStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategyPatch] { + return pulumix.Output[StatefulSetUpdateStrategyPatch]{ + OutputState: i.ToStatefulSetUpdateStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetUpdateStrategyPatchArgs) ToStatefulSetUpdateStrategyPatchPtrOutput() StatefulSetUpdateStrategyPatchPtrOutput { return i.ToStatefulSetUpdateStrategyPatchPtrOutputWithContext(context.Background()) } @@ -6415,6 +7214,12 @@ func (i *statefulSetUpdateStrategyPatchPtrType) ToStatefulSetUpdateStrategyPatch return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPatchPtrOutput) } +func (i *statefulSetUpdateStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategyPatch] { + return pulumix.Output[*StatefulSetUpdateStrategyPatch]{ + OutputState: i.ToStatefulSetUpdateStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. type StatefulSetUpdateStrategyPatchOutput struct{ *pulumi.OutputState } @@ -6440,6 +7245,12 @@ func (o StatefulSetUpdateStrategyPatchOutput) ToStatefulSetUpdateStrategyPatchPt }).(StatefulSetUpdateStrategyPatchPtrOutput) } +func (o StatefulSetUpdateStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategyPatch] { + return pulumix.Output[StatefulSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. func (o StatefulSetUpdateStrategyPatchOutput) RollingUpdate() RollingUpdateStatefulSetStrategyPatchPtrOutput { return o.ApplyT(func(v StatefulSetUpdateStrategyPatch) *RollingUpdateStatefulSetStrategyPatch { return v.RollingUpdate }).(RollingUpdateStatefulSetStrategyPatchPtrOutput) @@ -6464,6 +7275,12 @@ func (o StatefulSetUpdateStrategyPatchPtrOutput) ToStatefulSetUpdateStrategyPatc return o } +func (o StatefulSetUpdateStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategyPatch] { + return pulumix.Output[*StatefulSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetUpdateStrategyPatchPtrOutput) Elem() StatefulSetUpdateStrategyPatchOutput { return o.ApplyT(func(v *StatefulSetUpdateStrategyPatch) StatefulSetUpdateStrategyPatch { if v != nil { diff --git a/sdk/go/kubernetes/apps/v1beta1/statefulSet.go b/sdk/go/kubernetes/apps/v1beta1/statefulSet.go index 8ea6ca8650..fd04b5a446 100644 --- a/sdk/go/kubernetes/apps/v1beta1/statefulSet.go +++ b/sdk/go/kubernetes/apps/v1beta1/statefulSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StatefulSet represents a set of pods with consistent identities. Identities are defined as: @@ -139,6 +140,12 @@ func (i *StatefulSet) ToStatefulSetOutputWithContext(ctx context.Context) Statef return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOutput) } +func (i *StatefulSet) ToOutput(ctx context.Context) pulumix.Output[*StatefulSet] { + return pulumix.Output[*StatefulSet]{ + OutputState: i.ToStatefulSetOutputWithContext(ctx).OutputState, + } +} + // StatefulSetArrayInput is an input type that accepts StatefulSetArray and StatefulSetArrayOutput values. // You can construct a concrete instance of `StatefulSetArrayInput` via: // @@ -164,6 +171,12 @@ func (i StatefulSetArray) ToStatefulSetArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetArrayOutput) } +func (i StatefulSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSet] { + return pulumix.Output[[]*StatefulSet]{ + OutputState: i.ToStatefulSetArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetMapInput is an input type that accepts StatefulSetMap and StatefulSetMapOutput values. // You can construct a concrete instance of `StatefulSetMapInput` via: // @@ -189,6 +202,12 @@ func (i StatefulSetMap) ToStatefulSetMapOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(StatefulSetMapOutput) } +func (i StatefulSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSet] { + return pulumix.Output[map[string]*StatefulSet]{ + OutputState: i.ToStatefulSetMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetOutput struct{ *pulumi.OutputState } func (StatefulSetOutput) ElementType() reflect.Type { @@ -203,6 +222,12 @@ func (o StatefulSetOutput) ToStatefulSetOutputWithContext(ctx context.Context) S return o } +func (o StatefulSetOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSet] { + return pulumix.Output[*StatefulSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StatefulSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -241,6 +266,12 @@ func (o StatefulSetArrayOutput) ToStatefulSetArrayOutputWithContext(ctx context. return o } +func (o StatefulSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSet] { + return pulumix.Output[[]*StatefulSet]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetArrayOutput) Index(i pulumi.IntInput) StatefulSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSet { return vs[0].([]*StatefulSet)[vs[1].(int)] @@ -261,6 +292,12 @@ func (o StatefulSetMapOutput) ToStatefulSetMapOutputWithContext(ctx context.Cont return o } +func (o StatefulSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSet] { + return pulumix.Output[map[string]*StatefulSet]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetMapOutput) MapIndex(k pulumi.StringInput) StatefulSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSet { return vs[0].(map[string]*StatefulSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/statefulSetList.go b/sdk/go/kubernetes/apps/v1beta1/statefulSetList.go index 9b6b680d79..1bdc54e1b7 100644 --- a/sdk/go/kubernetes/apps/v1beta1/statefulSetList.go +++ b/sdk/go/kubernetes/apps/v1beta1/statefulSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StatefulSetList is a collection of StatefulSets. @@ -111,6 +112,12 @@ func (i *StatefulSetList) ToStatefulSetListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListOutput) } +func (i *StatefulSetList) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetList] { + return pulumix.Output[*StatefulSetList]{ + OutputState: i.ToStatefulSetListOutputWithContext(ctx).OutputState, + } +} + // StatefulSetListArrayInput is an input type that accepts StatefulSetListArray and StatefulSetListArrayOutput values. // You can construct a concrete instance of `StatefulSetListArrayInput` via: // @@ -136,6 +143,12 @@ func (i StatefulSetListArray) ToStatefulSetListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListArrayOutput) } +func (i StatefulSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetList] { + return pulumix.Output[[]*StatefulSetList]{ + OutputState: i.ToStatefulSetListArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetListMapInput is an input type that accepts StatefulSetListMap and StatefulSetListMapOutput values. // You can construct a concrete instance of `StatefulSetListMapInput` via: // @@ -161,6 +174,12 @@ func (i StatefulSetListMap) ToStatefulSetListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListMapOutput) } +func (i StatefulSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetList] { + return pulumix.Output[map[string]*StatefulSetList]{ + OutputState: i.ToStatefulSetListMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetListOutput struct{ *pulumi.OutputState } func (StatefulSetListOutput) ElementType() reflect.Type { @@ -175,6 +194,12 @@ func (o StatefulSetListOutput) ToStatefulSetListOutputWithContext(ctx context.Co return o } +func (o StatefulSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetList] { + return pulumix.Output[*StatefulSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StatefulSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -207,6 +232,12 @@ func (o StatefulSetListArrayOutput) ToStatefulSetListArrayOutputWithContext(ctx return o } +func (o StatefulSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetList] { + return pulumix.Output[[]*StatefulSetList]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetListArrayOutput) Index(i pulumi.IntInput) StatefulSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSetList { return vs[0].([]*StatefulSetList)[vs[1].(int)] @@ -227,6 +258,12 @@ func (o StatefulSetListMapOutput) ToStatefulSetListMapOutputWithContext(ctx cont return o } +func (o StatefulSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetList] { + return pulumix.Output[map[string]*StatefulSetList]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetListMapOutput) MapIndex(k pulumi.StringInput) StatefulSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSetList { return vs[0].(map[string]*StatefulSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta1/statefulSetPatch.go b/sdk/go/kubernetes/apps/v1beta1/statefulSetPatch.go index 2176f5e747..6119867c30 100644 --- a/sdk/go/kubernetes/apps/v1beta1/statefulSetPatch.go +++ b/sdk/go/kubernetes/apps/v1beta1/statefulSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -145,6 +146,12 @@ func (i *StatefulSetPatch) ToStatefulSetPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchOutput) } +func (i *StatefulSetPatch) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPatch] { + return pulumix.Output[*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPatchArrayInput is an input type that accepts StatefulSetPatchArray and StatefulSetPatchArrayOutput values. // You can construct a concrete instance of `StatefulSetPatchArrayInput` via: // @@ -170,6 +177,12 @@ func (i StatefulSetPatchArray) ToStatefulSetPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchArrayOutput) } +func (i StatefulSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetPatch] { + return pulumix.Output[[]*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPatchMapInput is an input type that accepts StatefulSetPatchMap and StatefulSetPatchMapOutput values. // You can construct a concrete instance of `StatefulSetPatchMapInput` via: // @@ -195,6 +208,12 @@ func (i StatefulSetPatchMap) ToStatefulSetPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchMapOutput) } +func (i StatefulSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetPatch] { + return pulumix.Output[map[string]*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetPatchOutput struct{ *pulumi.OutputState } func (StatefulSetPatchOutput) ElementType() reflect.Type { @@ -209,6 +228,12 @@ func (o StatefulSetPatchOutput) ToStatefulSetPatchOutputWithContext(ctx context. return o } +func (o StatefulSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPatch] { + return pulumix.Output[*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *StatefulSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -247,6 +272,12 @@ func (o StatefulSetPatchArrayOutput) ToStatefulSetPatchArrayOutputWithContext(ct return o } +func (o StatefulSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetPatch] { + return pulumix.Output[[]*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPatchArrayOutput) Index(i pulumi.IntInput) StatefulSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSetPatch { return vs[0].([]*StatefulSetPatch)[vs[1].(int)] @@ -267,6 +298,12 @@ func (o StatefulSetPatchMapOutput) ToStatefulSetPatchMapOutputWithContext(ctx co return o } +func (o StatefulSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetPatch] { + return pulumix.Output[map[string]*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPatchMapOutput) MapIndex(k pulumi.StringInput) StatefulSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSetPatch { return vs[0].(map[string]*StatefulSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/controllerRevision.go b/sdk/go/kubernetes/apps/v1beta2/controllerRevision.go index 9e392d5e18..9f5dd39838 100644 --- a/sdk/go/kubernetes/apps/v1beta2/controllerRevision.go +++ b/sdk/go/kubernetes/apps/v1beta2/controllerRevision.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. @@ -134,6 +135,12 @@ func (i *ControllerRevision) ToControllerRevisionOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionOutput) } +func (i *ControllerRevision) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevision] { + return pulumix.Output[*ControllerRevision]{ + OutputState: i.ToControllerRevisionOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionArrayInput is an input type that accepts ControllerRevisionArray and ControllerRevisionArrayOutput values. // You can construct a concrete instance of `ControllerRevisionArrayInput` via: // @@ -159,6 +166,12 @@ func (i ControllerRevisionArray) ToControllerRevisionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionArrayOutput) } +func (i ControllerRevisionArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevision] { + return pulumix.Output[[]*ControllerRevision]{ + OutputState: i.ToControllerRevisionArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionMapInput is an input type that accepts ControllerRevisionMap and ControllerRevisionMapOutput values. // You can construct a concrete instance of `ControllerRevisionMapInput` via: // @@ -184,6 +197,12 @@ func (i ControllerRevisionMap) ToControllerRevisionMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionMapOutput) } +func (i ControllerRevisionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevision] { + return pulumix.Output[map[string]*ControllerRevision]{ + OutputState: i.ToControllerRevisionMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionOutput struct{ *pulumi.OutputState } func (ControllerRevisionOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ControllerRevisionOutput) ToControllerRevisionOutputWithContext(ctx cont return o } +func (o ControllerRevisionOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevision] { + return pulumix.Output[*ControllerRevision]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ControllerRevision) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -237,6 +262,12 @@ func (o ControllerRevisionArrayOutput) ToControllerRevisionArrayOutputWithContex return o } +func (o ControllerRevisionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevision] { + return pulumix.Output[[]*ControllerRevision]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionArrayOutput) Index(i pulumi.IntInput) ControllerRevisionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevision { return vs[0].([]*ControllerRevision)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ControllerRevisionMapOutput) ToControllerRevisionMapOutputWithContext(ct return o } +func (o ControllerRevisionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevision] { + return pulumix.Output[map[string]*ControllerRevision]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevision { return vs[0].(map[string]*ControllerRevision)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/controllerRevisionList.go b/sdk/go/kubernetes/apps/v1beta2/controllerRevisionList.go index c88a9d833b..7043997a7f 100644 --- a/sdk/go/kubernetes/apps/v1beta2/controllerRevisionList.go +++ b/sdk/go/kubernetes/apps/v1beta2/controllerRevisionList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ControllerRevisionList is a resource containing a list of ControllerRevision objects. @@ -117,6 +118,12 @@ func (i *ControllerRevisionList) ToControllerRevisionListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListOutput) } +func (i *ControllerRevisionList) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionList] { + return pulumix.Output[*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionListArrayInput is an input type that accepts ControllerRevisionListArray and ControllerRevisionListArrayOutput values. // You can construct a concrete instance of `ControllerRevisionListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ControllerRevisionListArray) ToControllerRevisionListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListArrayOutput) } +func (i ControllerRevisionListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionList] { + return pulumix.Output[[]*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionListMapInput is an input type that accepts ControllerRevisionListMap and ControllerRevisionListMapOutput values. // You can construct a concrete instance of `ControllerRevisionListMapInput` via: // @@ -167,6 +180,12 @@ func (i ControllerRevisionListMap) ToControllerRevisionListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListMapOutput) } +func (i ControllerRevisionListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionList] { + return pulumix.Output[map[string]*ControllerRevisionList]{ + OutputState: i.ToControllerRevisionListMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionListOutput struct{ *pulumi.OutputState } func (ControllerRevisionListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ControllerRevisionListOutput) ToControllerRevisionListOutputWithContext( return o } +func (o ControllerRevisionListOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionList] { + return pulumix.Output[*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ControllerRevisionList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ControllerRevisionListArrayOutput) ToControllerRevisionListArrayOutputWi return o } +func (o ControllerRevisionListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionList] { + return pulumix.Output[[]*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionListArrayOutput) Index(i pulumi.IntInput) ControllerRevisionListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevisionList { return vs[0].([]*ControllerRevisionList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ControllerRevisionListMapOutput) ToControllerRevisionListMapOutputWithCo return o } +func (o ControllerRevisionListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionList] { + return pulumix.Output[map[string]*ControllerRevisionList]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionListMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevisionList { return vs[0].(map[string]*ControllerRevisionList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/controllerRevisionPatch.go b/sdk/go/kubernetes/apps/v1beta2/controllerRevisionPatch.go index 51aca81f93..503487b5e0 100644 --- a/sdk/go/kubernetes/apps/v1beta2/controllerRevisionPatch.go +++ b/sdk/go/kubernetes/apps/v1beta2/controllerRevisionPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -136,6 +137,12 @@ func (i *ControllerRevisionPatch) ToControllerRevisionPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchOutput) } +func (i *ControllerRevisionPatch) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionPatch] { + return pulumix.Output[*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionPatchArrayInput is an input type that accepts ControllerRevisionPatchArray and ControllerRevisionPatchArrayOutput values. // You can construct a concrete instance of `ControllerRevisionPatchArrayInput` via: // @@ -161,6 +168,12 @@ func (i ControllerRevisionPatchArray) ToControllerRevisionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchArrayOutput) } +func (i ControllerRevisionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionPatch] { + return pulumix.Output[[]*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionPatchMapInput is an input type that accepts ControllerRevisionPatchMap and ControllerRevisionPatchMapOutput values. // You can construct a concrete instance of `ControllerRevisionPatchMapInput` via: // @@ -186,6 +199,12 @@ func (i ControllerRevisionPatchMap) ToControllerRevisionPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchMapOutput) } +func (i ControllerRevisionPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionPatch] { + return pulumix.Output[map[string]*ControllerRevisionPatch]{ + OutputState: i.ToControllerRevisionPatchMapOutputWithContext(ctx).OutputState, + } +} + type ControllerRevisionPatchOutput struct{ *pulumi.OutputState } func (ControllerRevisionPatchOutput) ElementType() reflect.Type { @@ -200,6 +219,12 @@ func (o ControllerRevisionPatchOutput) ToControllerRevisionPatchOutputWithContex return o } +func (o ControllerRevisionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ControllerRevisionPatch] { + return pulumix.Output[*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ControllerRevisionPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -239,6 +264,12 @@ func (o ControllerRevisionPatchArrayOutput) ToControllerRevisionPatchArrayOutput return o } +func (o ControllerRevisionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ControllerRevisionPatch] { + return pulumix.Output[[]*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionPatchArrayOutput) Index(i pulumi.IntInput) ControllerRevisionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ControllerRevisionPatch { return vs[0].([]*ControllerRevisionPatch)[vs[1].(int)] @@ -259,6 +290,12 @@ func (o ControllerRevisionPatchMapOutput) ToControllerRevisionPatchMapOutputWith return o } +func (o ControllerRevisionPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ControllerRevisionPatch] { + return pulumix.Output[map[string]*ControllerRevisionPatch]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionPatchMapOutput) MapIndex(k pulumi.StringInput) ControllerRevisionPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ControllerRevisionPatch { return vs[0].(map[string]*ControllerRevisionPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/daemonSet.go b/sdk/go/kubernetes/apps/v1beta2/daemonSet.go index 9fa580b986..2dcfbfeaeb 100644 --- a/sdk/go/kubernetes/apps/v1beta2/daemonSet.go +++ b/sdk/go/kubernetes/apps/v1beta2/daemonSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DaemonSet represents the configuration of a daemon set. @@ -126,6 +127,12 @@ func (i *DaemonSet) ToDaemonSetOutputWithContext(ctx context.Context) DaemonSetO return pulumi.ToOutputWithContext(ctx, i).(DaemonSetOutput) } +func (i *DaemonSet) ToOutput(ctx context.Context) pulumix.Output[*DaemonSet] { + return pulumix.Output[*DaemonSet]{ + OutputState: i.ToDaemonSetOutputWithContext(ctx).OutputState, + } +} + // DaemonSetArrayInput is an input type that accepts DaemonSetArray and DaemonSetArrayOutput values. // You can construct a concrete instance of `DaemonSetArrayInput` via: // @@ -151,6 +158,12 @@ func (i DaemonSetArray) ToDaemonSetArrayOutputWithContext(ctx context.Context) D return pulumi.ToOutputWithContext(ctx, i).(DaemonSetArrayOutput) } +func (i DaemonSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSet] { + return pulumix.Output[[]*DaemonSet]{ + OutputState: i.ToDaemonSetArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetMapInput is an input type that accepts DaemonSetMap and DaemonSetMapOutput values. // You can construct a concrete instance of `DaemonSetMapInput` via: // @@ -176,6 +189,12 @@ func (i DaemonSetMap) ToDaemonSetMapOutputWithContext(ctx context.Context) Daemo return pulumi.ToOutputWithContext(ctx, i).(DaemonSetMapOutput) } +func (i DaemonSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSet] { + return pulumix.Output[map[string]*DaemonSet]{ + OutputState: i.ToDaemonSetMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetOutput struct{ *pulumi.OutputState } func (DaemonSetOutput) ElementType() reflect.Type { @@ -190,6 +209,12 @@ func (o DaemonSetOutput) ToDaemonSetOutputWithContext(ctx context.Context) Daemo return o } +func (o DaemonSetOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSet] { + return pulumix.Output[*DaemonSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DaemonSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -229,6 +254,12 @@ func (o DaemonSetArrayOutput) ToDaemonSetArrayOutputWithContext(ctx context.Cont return o } +func (o DaemonSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSet] { + return pulumix.Output[[]*DaemonSet]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetArrayOutput) Index(i pulumi.IntInput) DaemonSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSet { return vs[0].([]*DaemonSet)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o DaemonSetMapOutput) ToDaemonSetMapOutputWithContext(ctx context.Context) return o } +func (o DaemonSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSet] { + return pulumix.Output[map[string]*DaemonSet]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetMapOutput) MapIndex(k pulumi.StringInput) DaemonSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSet { return vs[0].(map[string]*DaemonSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/daemonSetList.go b/sdk/go/kubernetes/apps/v1beta2/daemonSetList.go index da46e1726d..a66a43bcf7 100644 --- a/sdk/go/kubernetes/apps/v1beta2/daemonSetList.go +++ b/sdk/go/kubernetes/apps/v1beta2/daemonSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DaemonSetList is a collection of daemon sets. @@ -117,6 +118,12 @@ func (i *DaemonSetList) ToDaemonSetListOutputWithContext(ctx context.Context) Da return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListOutput) } +func (i *DaemonSetList) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetList] { + return pulumix.Output[*DaemonSetList]{ + OutputState: i.ToDaemonSetListOutputWithContext(ctx).OutputState, + } +} + // DaemonSetListArrayInput is an input type that accepts DaemonSetListArray and DaemonSetListArrayOutput values. // You can construct a concrete instance of `DaemonSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DaemonSetListArray) ToDaemonSetListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListArrayOutput) } +func (i DaemonSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetList] { + return pulumix.Output[[]*DaemonSetList]{ + OutputState: i.ToDaemonSetListArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetListMapInput is an input type that accepts DaemonSetListMap and DaemonSetListMapOutput values. // You can construct a concrete instance of `DaemonSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i DaemonSetListMap) ToDaemonSetListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListMapOutput) } +func (i DaemonSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetList] { + return pulumix.Output[map[string]*DaemonSetList]{ + OutputState: i.ToDaemonSetListMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetListOutput struct{ *pulumi.OutputState } func (DaemonSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DaemonSetListOutput) ToDaemonSetListOutputWithContext(ctx context.Contex return o } +func (o DaemonSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetList] { + return pulumix.Output[*DaemonSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DaemonSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DaemonSetListArrayOutput) ToDaemonSetListArrayOutputWithContext(ctx cont return o } +func (o DaemonSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetList] { + return pulumix.Output[[]*DaemonSetList]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetListArrayOutput) Index(i pulumi.IntInput) DaemonSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSetList { return vs[0].([]*DaemonSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DaemonSetListMapOutput) ToDaemonSetListMapOutputWithContext(ctx context. return o } +func (o DaemonSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetList] { + return pulumix.Output[map[string]*DaemonSetList]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetListMapOutput) MapIndex(k pulumi.StringInput) DaemonSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSetList { return vs[0].(map[string]*DaemonSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/daemonSetPatch.go b/sdk/go/kubernetes/apps/v1beta2/daemonSetPatch.go index 6d4063d786..ae2cd715cb 100644 --- a/sdk/go/kubernetes/apps/v1beta2/daemonSetPatch.go +++ b/sdk/go/kubernetes/apps/v1beta2/daemonSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *DaemonSetPatch) ToDaemonSetPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchOutput) } +func (i *DaemonSetPatch) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetPatch] { + return pulumix.Output[*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchOutputWithContext(ctx).OutputState, + } +} + // DaemonSetPatchArrayInput is an input type that accepts DaemonSetPatchArray and DaemonSetPatchArrayOutput values. // You can construct a concrete instance of `DaemonSetPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i DaemonSetPatchArray) ToDaemonSetPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchArrayOutput) } +func (i DaemonSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetPatch] { + return pulumix.Output[[]*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetPatchMapInput is an input type that accepts DaemonSetPatchMap and DaemonSetPatchMapOutput values. // You can construct a concrete instance of `DaemonSetPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i DaemonSetPatchMap) ToDaemonSetPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchMapOutput) } +func (i DaemonSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetPatch] { + return pulumix.Output[map[string]*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetPatchOutput struct{ *pulumi.OutputState } func (DaemonSetPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o DaemonSetPatchOutput) ToDaemonSetPatchOutputWithContext(ctx context.Cont return o } +func (o DaemonSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetPatch] { + return pulumix.Output[*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DaemonSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o DaemonSetPatchArrayOutput) ToDaemonSetPatchArrayOutputWithContext(ctx co return o } +func (o DaemonSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetPatch] { + return pulumix.Output[[]*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetPatchArrayOutput) Index(i pulumi.IntInput) DaemonSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSetPatch { return vs[0].([]*DaemonSetPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o DaemonSetPatchMapOutput) ToDaemonSetPatchMapOutputWithContext(ctx contex return o } +func (o DaemonSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetPatch] { + return pulumix.Output[map[string]*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetPatchMapOutput) MapIndex(k pulumi.StringInput) DaemonSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSetPatch { return vs[0].(map[string]*DaemonSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/deployment.go b/sdk/go/kubernetes/apps/v1beta2/deployment.go index cadd48f1ac..42e0dfdded 100644 --- a/sdk/go/kubernetes/apps/v1beta2/deployment.go +++ b/sdk/go/kubernetes/apps/v1beta2/deployment.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Deployment enables declarative updates for Pods and ReplicaSets. @@ -151,6 +152,12 @@ func (i *Deployment) ToDeploymentOutputWithContext(ctx context.Context) Deployme return pulumi.ToOutputWithContext(ctx, i).(DeploymentOutput) } +func (i *Deployment) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: i.ToDeploymentOutputWithContext(ctx).OutputState, + } +} + // DeploymentArrayInput is an input type that accepts DeploymentArray and DeploymentArrayOutput values. // You can construct a concrete instance of `DeploymentArrayInput` via: // @@ -176,6 +183,12 @@ func (i DeploymentArray) ToDeploymentArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentArrayOutput) } +func (i DeploymentArray) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: i.ToDeploymentArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentMapInput is an input type that accepts DeploymentMap and DeploymentMapOutput values. // You can construct a concrete instance of `DeploymentMapInput` via: // @@ -201,6 +214,12 @@ func (i DeploymentMap) ToDeploymentMapOutputWithContext(ctx context.Context) Dep return pulumi.ToOutputWithContext(ctx, i).(DeploymentMapOutput) } +func (i DeploymentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: i.ToDeploymentMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentOutput struct{ *pulumi.OutputState } func (DeploymentOutput) ElementType() reflect.Type { @@ -215,6 +234,12 @@ func (o DeploymentOutput) ToDeploymentOutputWithContext(ctx context.Context) Dep return o } +func (o DeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Deployment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -254,6 +279,12 @@ func (o DeploymentArrayOutput) ToDeploymentArrayOutputWithContext(ctx context.Co return o } +func (o DeploymentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentArrayOutput) Index(i pulumi.IntInput) DeploymentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Deployment { return vs[0].([]*Deployment)[vs[1].(int)] @@ -274,6 +305,12 @@ func (o DeploymentMapOutput) ToDeploymentMapOutputWithContext(ctx context.Contex return o } +func (o DeploymentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentMapOutput) MapIndex(k pulumi.StringInput) DeploymentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Deployment { return vs[0].(map[string]*Deployment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/deploymentList.go b/sdk/go/kubernetes/apps/v1beta2/deploymentList.go index ce04afbfc9..e76482f1ba 100644 --- a/sdk/go/kubernetes/apps/v1beta2/deploymentList.go +++ b/sdk/go/kubernetes/apps/v1beta2/deploymentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DeploymentList is a list of Deployments. @@ -117,6 +118,12 @@ func (i *DeploymentList) ToDeploymentListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentListOutput) } +func (i *DeploymentList) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: i.ToDeploymentListOutputWithContext(ctx).OutputState, + } +} + // DeploymentListArrayInput is an input type that accepts DeploymentListArray and DeploymentListArrayOutput values. // You can construct a concrete instance of `DeploymentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DeploymentListArray) ToDeploymentListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentListArrayOutput) } +func (i DeploymentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: i.ToDeploymentListArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentListMapInput is an input type that accepts DeploymentListMap and DeploymentListMapOutput values. // You can construct a concrete instance of `DeploymentListMapInput` via: // @@ -167,6 +180,12 @@ func (i DeploymentListMap) ToDeploymentListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentListMapOutput) } +func (i DeploymentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: i.ToDeploymentListMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentListOutput struct{ *pulumi.OutputState } func (DeploymentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DeploymentListOutput) ToDeploymentListOutputWithContext(ctx context.Cont return o } +func (o DeploymentListOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DeploymentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DeploymentListArrayOutput) ToDeploymentListArrayOutputWithContext(ctx co return o } +func (o DeploymentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListArrayOutput) Index(i pulumi.IntInput) DeploymentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].([]*DeploymentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DeploymentListMapOutput) ToDeploymentListMapOutputWithContext(ctx contex return o } +func (o DeploymentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListMapOutput) MapIndex(k pulumi.StringInput) DeploymentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].(map[string]*DeploymentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/deploymentPatch.go b/sdk/go/kubernetes/apps/v1beta2/deploymentPatch.go index 34fd2536b3..a2222fe908 100644 --- a/sdk/go/kubernetes/apps/v1beta2/deploymentPatch.go +++ b/sdk/go/kubernetes/apps/v1beta2/deploymentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -157,6 +158,12 @@ func (i *DeploymentPatch) ToDeploymentPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchOutput) } +func (i *DeploymentPatch) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchArrayInput is an input type that accepts DeploymentPatchArray and DeploymentPatchArrayOutput values. // You can construct a concrete instance of `DeploymentPatchArrayInput` via: // @@ -182,6 +189,12 @@ func (i DeploymentPatchArray) ToDeploymentPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchArrayOutput) } +func (i DeploymentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchMapInput is an input type that accepts DeploymentPatchMap and DeploymentPatchMapOutput values. // You can construct a concrete instance of `DeploymentPatchMapInput` via: // @@ -207,6 +220,12 @@ func (i DeploymentPatchMap) ToDeploymentPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchMapOutput) } +func (i DeploymentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentPatchOutput struct{ *pulumi.OutputState } func (DeploymentPatchOutput) ElementType() reflect.Type { @@ -221,6 +240,12 @@ func (o DeploymentPatchOutput) ToDeploymentPatchOutputWithContext(ctx context.Co return o } +func (o DeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DeploymentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -260,6 +285,12 @@ func (o DeploymentPatchArrayOutput) ToDeploymentPatchArrayOutputWithContext(ctx return o } +func (o DeploymentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchArrayOutput) Index(i pulumi.IntInput) DeploymentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].([]*DeploymentPatch)[vs[1].(int)] @@ -280,6 +311,12 @@ func (o DeploymentPatchMapOutput) ToDeploymentPatchMapOutputWithContext(ctx cont return o } +func (o DeploymentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchMapOutput) MapIndex(k pulumi.StringInput) DeploymentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].(map[string]*DeploymentPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/pulumiTypes.go b/sdk/go/kubernetes/apps/v1beta2/pulumiTypes.go index 8f3af69da3..c3344d725f 100644 --- a/sdk/go/kubernetes/apps/v1beta2/pulumiTypes.go +++ b/sdk/go/kubernetes/apps/v1beta2/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -66,6 +67,12 @@ func (i ControllerRevisionTypeArgs) ToControllerRevisionTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionTypeOutput) } +func (i ControllerRevisionTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionType] { + return pulumix.Output[ControllerRevisionType]{ + OutputState: i.ToControllerRevisionTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionTypeArrayInput is an input type that accepts ControllerRevisionTypeArray and ControllerRevisionTypeArrayOutput values. // You can construct a concrete instance of `ControllerRevisionTypeArrayInput` via: // @@ -91,6 +98,12 @@ func (i ControllerRevisionTypeArray) ToControllerRevisionTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionTypeArrayOutput) } +func (i ControllerRevisionTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ControllerRevisionType] { + return pulumix.Output[[]ControllerRevisionType]{ + OutputState: i.ToControllerRevisionTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. type ControllerRevisionTypeOutput struct{ *pulumi.OutputState } @@ -106,6 +119,12 @@ func (o ControllerRevisionTypeOutput) ToControllerRevisionTypeOutputWithContext( return o } +func (o ControllerRevisionTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionType] { + return pulumix.Output[ControllerRevisionType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -145,6 +164,12 @@ func (o ControllerRevisionTypeArrayOutput) ToControllerRevisionTypeArrayOutputWi return o } +func (o ControllerRevisionTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ControllerRevisionType] { + return pulumix.Output[[]ControllerRevisionType]{ + OutputState: o.OutputState, + } +} + func (o ControllerRevisionTypeArrayOutput) Index(i pulumi.IntInput) ControllerRevisionTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ControllerRevisionType { return vs[0].([]ControllerRevisionType)[vs[1].(int)] @@ -198,6 +223,12 @@ func (i ControllerRevisionListTypeArgs) ToControllerRevisionListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionListTypeOutput) } +func (i ControllerRevisionListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionListType] { + return pulumix.Output[ControllerRevisionListType]{ + OutputState: i.ToControllerRevisionListTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevisionList is a resource containing a list of ControllerRevision objects. type ControllerRevisionListTypeOutput struct{ *pulumi.OutputState } @@ -213,6 +244,12 @@ func (o ControllerRevisionListTypeOutput) ToControllerRevisionListTypeOutputWith return o } +func (o ControllerRevisionListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionListType] { + return pulumix.Output[ControllerRevisionListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -284,6 +321,12 @@ func (i ControllerRevisionPatchTypeArgs) ToControllerRevisionPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ControllerRevisionPatchTypeOutput) } +func (i ControllerRevisionPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionPatchType] { + return pulumix.Output[ControllerRevisionPatchType]{ + OutputState: i.ToControllerRevisionPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. type ControllerRevisionPatchTypeOutput struct{ *pulumi.OutputState } @@ -299,6 +342,12 @@ func (o ControllerRevisionPatchTypeOutput) ToControllerRevisionPatchTypeOutputWi return o } +func (o ControllerRevisionPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ControllerRevisionPatchType] { + return pulumix.Output[ControllerRevisionPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ControllerRevisionPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ControllerRevisionPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -375,6 +424,12 @@ func (i DaemonSetTypeArgs) ToDaemonSetTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetTypeOutput) } +func (i DaemonSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetType] { + return pulumix.Output[DaemonSetType]{ + OutputState: i.ToDaemonSetTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSetTypeArrayInput is an input type that accepts DaemonSetTypeArray and DaemonSetTypeArrayOutput values. // You can construct a concrete instance of `DaemonSetTypeArrayInput` via: // @@ -400,6 +455,12 @@ func (i DaemonSetTypeArray) ToDaemonSetTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetTypeArrayOutput) } +func (i DaemonSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetType] { + return pulumix.Output[[]DaemonSetType]{ + OutputState: i.ToDaemonSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSet represents the configuration of a daemon set. type DaemonSetTypeOutput struct{ *pulumi.OutputState } @@ -415,6 +476,12 @@ func (o DaemonSetTypeOutput) ToDaemonSetTypeOutputWithContext(ctx context.Contex return o } +func (o DaemonSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetType] { + return pulumix.Output[DaemonSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -454,6 +521,12 @@ func (o DaemonSetTypeArrayOutput) ToDaemonSetTypeArrayOutputWithContext(ctx cont return o } +func (o DaemonSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetType] { + return pulumix.Output[[]DaemonSetType]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetTypeArrayOutput) Index(i pulumi.IntInput) DaemonSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetType { return vs[0].([]DaemonSetType)[vs[1].(int)] @@ -511,6 +584,12 @@ func (i DaemonSetConditionArgs) ToDaemonSetConditionOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionOutput) } +func (i DaemonSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetCondition] { + return pulumix.Output[DaemonSetCondition]{ + OutputState: i.ToDaemonSetConditionOutputWithContext(ctx).OutputState, + } +} + // DaemonSetConditionArrayInput is an input type that accepts DaemonSetConditionArray and DaemonSetConditionArrayOutput values. // You can construct a concrete instance of `DaemonSetConditionArrayInput` via: // @@ -536,6 +615,12 @@ func (i DaemonSetConditionArray) ToDaemonSetConditionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionArrayOutput) } +func (i DaemonSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetCondition] { + return pulumix.Output[[]DaemonSetCondition]{ + OutputState: i.ToDaemonSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetCondition describes the state of a DaemonSet at a certain point. type DaemonSetConditionOutput struct{ *pulumi.OutputState } @@ -551,6 +636,12 @@ func (o DaemonSetConditionOutput) ToDaemonSetConditionOutputWithContext(ctx cont return o } +func (o DaemonSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetCondition] { + return pulumix.Output[DaemonSetCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DaemonSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -590,6 +681,12 @@ func (o DaemonSetConditionArrayOutput) ToDaemonSetConditionArrayOutputWithContex return o } +func (o DaemonSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetCondition] { + return pulumix.Output[[]DaemonSetCondition]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetConditionArrayOutput) Index(i pulumi.IntInput) DaemonSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetCondition { return vs[0].([]DaemonSetCondition)[vs[1].(int)] @@ -647,6 +744,12 @@ func (i DaemonSetConditionPatchArgs) ToDaemonSetConditionPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionPatchOutput) } +func (i DaemonSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetConditionPatch] { + return pulumix.Output[DaemonSetConditionPatch]{ + OutputState: i.ToDaemonSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DaemonSetConditionPatchArrayInput is an input type that accepts DaemonSetConditionPatchArray and DaemonSetConditionPatchArrayOutput values. // You can construct a concrete instance of `DaemonSetConditionPatchArrayInput` via: // @@ -672,6 +775,12 @@ func (i DaemonSetConditionPatchArray) ToDaemonSetConditionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionPatchArrayOutput) } +func (i DaemonSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetConditionPatch] { + return pulumix.Output[[]DaemonSetConditionPatch]{ + OutputState: i.ToDaemonSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetCondition describes the state of a DaemonSet at a certain point. type DaemonSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -687,6 +796,12 @@ func (o DaemonSetConditionPatchOutput) ToDaemonSetConditionPatchOutputWithContex return o } +func (o DaemonSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetConditionPatch] { + return pulumix.Output[DaemonSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DaemonSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -726,6 +841,12 @@ func (o DaemonSetConditionPatchArrayOutput) ToDaemonSetConditionPatchArrayOutput return o } +func (o DaemonSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetConditionPatch] { + return pulumix.Output[[]DaemonSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetConditionPatchArrayOutput) Index(i pulumi.IntInput) DaemonSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetConditionPatch { return vs[0].([]DaemonSetConditionPatch)[vs[1].(int)] @@ -779,6 +900,12 @@ func (i DaemonSetListTypeArgs) ToDaemonSetListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListTypeOutput) } +func (i DaemonSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetListType] { + return pulumix.Output[DaemonSetListType]{ + OutputState: i.ToDaemonSetListTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSetList is a collection of daemon sets. type DaemonSetListTypeOutput struct{ *pulumi.OutputState } @@ -794,6 +921,12 @@ func (o DaemonSetListTypeOutput) ToDaemonSetListTypeOutputWithContext(ctx contex return o } +func (o DaemonSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetListType] { + return pulumix.Output[DaemonSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -865,6 +998,12 @@ func (i DaemonSetPatchTypeArgs) ToDaemonSetPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchTypeOutput) } +func (i DaemonSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetPatchType] { + return pulumix.Output[DaemonSetPatchType]{ + OutputState: i.ToDaemonSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSet represents the configuration of a daemon set. type DaemonSetPatchTypeOutput struct{ *pulumi.OutputState } @@ -880,6 +1019,12 @@ func (o DaemonSetPatchTypeOutput) ToDaemonSetPatchTypeOutputWithContext(ctx cont return o } +func (o DaemonSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetPatchType] { + return pulumix.Output[DaemonSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -956,6 +1101,12 @@ func (i DaemonSetSpecArgs) ToDaemonSetSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecOutput) } +func (i DaemonSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpec] { + return pulumix.Output[DaemonSetSpec]{ + OutputState: i.ToDaemonSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetSpecArgs) ToDaemonSetSpecPtrOutput() DaemonSetSpecPtrOutput { return i.ToDaemonSetSpecPtrOutputWithContext(context.Background()) } @@ -997,6 +1148,12 @@ func (i *daemonSetSpecPtrType) ToDaemonSetSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPtrOutput) } +func (i *daemonSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpec] { + return pulumix.Output[*DaemonSetSpec]{ + OutputState: i.ToDaemonSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetSpec is the specification of a daemon set. type DaemonSetSpecOutput struct{ *pulumi.OutputState } @@ -1022,6 +1179,12 @@ func (o DaemonSetSpecOutput) ToDaemonSetSpecPtrOutputWithContext(ctx context.Con }).(DaemonSetSpecPtrOutput) } +func (o DaemonSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpec] { + return pulumix.Output[DaemonSetSpec]{ + OutputState: o.OutputState, + } +} + // The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). func (o DaemonSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1061,6 +1224,12 @@ func (o DaemonSetSpecPtrOutput) ToDaemonSetSpecPtrOutputWithContext(ctx context. return o } +func (o DaemonSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpec] { + return pulumix.Output[*DaemonSetSpec]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetSpecPtrOutput) Elem() DaemonSetSpecOutput { return o.ApplyT(func(v *DaemonSetSpec) DaemonSetSpec { if v != nil { @@ -1172,6 +1341,12 @@ func (i DaemonSetSpecPatchArgs) ToDaemonSetSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPatchOutput) } +func (i DaemonSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpecPatch] { + return pulumix.Output[DaemonSetSpecPatch]{ + OutputState: i.ToDaemonSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetSpecPatchArgs) ToDaemonSetSpecPatchPtrOutput() DaemonSetSpecPatchPtrOutput { return i.ToDaemonSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -1213,6 +1388,12 @@ func (i *daemonSetSpecPatchPtrType) ToDaemonSetSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPatchPtrOutput) } +func (i *daemonSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpecPatch] { + return pulumix.Output[*DaemonSetSpecPatch]{ + OutputState: i.ToDaemonSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetSpec is the specification of a daemon set. type DaemonSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -1238,6 +1419,12 @@ func (o DaemonSetSpecPatchOutput) ToDaemonSetSpecPatchPtrOutputWithContext(ctx c }).(DaemonSetSpecPatchPtrOutput) } +func (o DaemonSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpecPatch] { + return pulumix.Output[DaemonSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). func (o DaemonSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1277,6 +1464,12 @@ func (o DaemonSetSpecPatchPtrOutput) ToDaemonSetSpecPatchPtrOutputWithContext(ct return o } +func (o DaemonSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpecPatch] { + return pulumix.Output[*DaemonSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetSpecPatchPtrOutput) Elem() DaemonSetSpecPatchOutput { return o.ApplyT(func(v *DaemonSetSpecPatch) DaemonSetSpecPatch { if v != nil { @@ -1408,6 +1601,12 @@ func (i DaemonSetStatusArgs) ToDaemonSetStatusOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusOutput) } +func (i DaemonSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatus] { + return pulumix.Output[DaemonSetStatus]{ + OutputState: i.ToDaemonSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetStatusArgs) ToDaemonSetStatusPtrOutput() DaemonSetStatusPtrOutput { return i.ToDaemonSetStatusPtrOutputWithContext(context.Background()) } @@ -1449,6 +1648,12 @@ func (i *daemonSetStatusPtrType) ToDaemonSetStatusPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPtrOutput) } +func (i *daemonSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatus] { + return pulumix.Output[*DaemonSetStatus]{ + OutputState: i.ToDaemonSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetStatus represents the current status of a daemon set. type DaemonSetStatusOutput struct{ *pulumi.OutputState } @@ -1474,6 +1679,12 @@ func (o DaemonSetStatusOutput) ToDaemonSetStatusPtrOutputWithContext(ctx context }).(DaemonSetStatusPtrOutput) } +func (o DaemonSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatus] { + return pulumix.Output[DaemonSetStatus]{ + OutputState: o.OutputState, + } +} + // Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o DaemonSetStatusOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetStatus) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -1538,6 +1749,12 @@ func (o DaemonSetStatusPtrOutput) ToDaemonSetStatusPtrOutputWithContext(ctx cont return o } +func (o DaemonSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatus] { + return pulumix.Output[*DaemonSetStatus]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetStatusPtrOutput) Elem() DaemonSetStatusOutput { return o.ApplyT(func(v *DaemonSetStatus) DaemonSetStatus { if v != nil { @@ -1719,6 +1936,12 @@ func (i DaemonSetStatusPatchArgs) ToDaemonSetStatusPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPatchOutput) } +func (i DaemonSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatusPatch] { + return pulumix.Output[DaemonSetStatusPatch]{ + OutputState: i.ToDaemonSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetStatusPatchArgs) ToDaemonSetStatusPatchPtrOutput() DaemonSetStatusPatchPtrOutput { return i.ToDaemonSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -1760,6 +1983,12 @@ func (i *daemonSetStatusPatchPtrType) ToDaemonSetStatusPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPatchPtrOutput) } +func (i *daemonSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatusPatch] { + return pulumix.Output[*DaemonSetStatusPatch]{ + OutputState: i.ToDaemonSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetStatus represents the current status of a daemon set. type DaemonSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -1785,6 +2014,12 @@ func (o DaemonSetStatusPatchOutput) ToDaemonSetStatusPatchPtrOutputWithContext(c }).(DaemonSetStatusPatchPtrOutput) } +func (o DaemonSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatusPatch] { + return pulumix.Output[DaemonSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o DaemonSetStatusPatchOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetStatusPatch) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -1849,6 +2084,12 @@ func (o DaemonSetStatusPatchPtrOutput) ToDaemonSetStatusPatchPtrOutputWithContex return o } +func (o DaemonSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatusPatch] { + return pulumix.Output[*DaemonSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetStatusPatchPtrOutput) Elem() DaemonSetStatusPatchOutput { return o.ApplyT(func(v *DaemonSetStatusPatch) DaemonSetStatusPatch { if v != nil { @@ -1998,6 +2239,12 @@ func (i DaemonSetUpdateStrategyArgs) ToDaemonSetUpdateStrategyOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyOutput) } +func (i DaemonSetUpdateStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategy] { + return pulumix.Output[DaemonSetUpdateStrategy]{ + OutputState: i.ToDaemonSetUpdateStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetUpdateStrategyArgs) ToDaemonSetUpdateStrategyPtrOutput() DaemonSetUpdateStrategyPtrOutput { return i.ToDaemonSetUpdateStrategyPtrOutputWithContext(context.Background()) } @@ -2039,6 +2286,12 @@ func (i *daemonSetUpdateStrategyPtrType) ToDaemonSetUpdateStrategyPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPtrOutput) } +func (i *daemonSetUpdateStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategy] { + return pulumix.Output[*DaemonSetUpdateStrategy]{ + OutputState: i.ToDaemonSetUpdateStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. type DaemonSetUpdateStrategyOutput struct{ *pulumi.OutputState } @@ -2064,6 +2317,12 @@ func (o DaemonSetUpdateStrategyOutput) ToDaemonSetUpdateStrategyPtrOutputWithCon }).(DaemonSetUpdateStrategyPtrOutput) } +func (o DaemonSetUpdateStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategy] { + return pulumix.Output[DaemonSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if type = "RollingUpdate". func (o DaemonSetUpdateStrategyOutput) RollingUpdate() RollingUpdateDaemonSetPtrOutput { return o.ApplyT(func(v DaemonSetUpdateStrategy) *RollingUpdateDaemonSet { return v.RollingUpdate }).(RollingUpdateDaemonSetPtrOutput) @@ -2088,6 +2347,12 @@ func (o DaemonSetUpdateStrategyPtrOutput) ToDaemonSetUpdateStrategyPtrOutputWith return o } +func (o DaemonSetUpdateStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategy] { + return pulumix.Output[*DaemonSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetUpdateStrategyPtrOutput) Elem() DaemonSetUpdateStrategyOutput { return o.ApplyT(func(v *DaemonSetUpdateStrategy) DaemonSetUpdateStrategy { if v != nil { @@ -2157,6 +2422,12 @@ func (i DaemonSetUpdateStrategyPatchArgs) ToDaemonSetUpdateStrategyPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPatchOutput) } +func (i DaemonSetUpdateStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategyPatch] { + return pulumix.Output[DaemonSetUpdateStrategyPatch]{ + OutputState: i.ToDaemonSetUpdateStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetUpdateStrategyPatchArgs) ToDaemonSetUpdateStrategyPatchPtrOutput() DaemonSetUpdateStrategyPatchPtrOutput { return i.ToDaemonSetUpdateStrategyPatchPtrOutputWithContext(context.Background()) } @@ -2198,6 +2469,12 @@ func (i *daemonSetUpdateStrategyPatchPtrType) ToDaemonSetUpdateStrategyPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPatchPtrOutput) } +func (i *daemonSetUpdateStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategyPatch] { + return pulumix.Output[*DaemonSetUpdateStrategyPatch]{ + OutputState: i.ToDaemonSetUpdateStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. type DaemonSetUpdateStrategyPatchOutput struct{ *pulumi.OutputState } @@ -2223,6 +2500,12 @@ func (o DaemonSetUpdateStrategyPatchOutput) ToDaemonSetUpdateStrategyPatchPtrOut }).(DaemonSetUpdateStrategyPatchPtrOutput) } +func (o DaemonSetUpdateStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategyPatch] { + return pulumix.Output[DaemonSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if type = "RollingUpdate". func (o DaemonSetUpdateStrategyPatchOutput) RollingUpdate() RollingUpdateDaemonSetPatchPtrOutput { return o.ApplyT(func(v DaemonSetUpdateStrategyPatch) *RollingUpdateDaemonSetPatch { return v.RollingUpdate }).(RollingUpdateDaemonSetPatchPtrOutput) @@ -2247,6 +2530,12 @@ func (o DaemonSetUpdateStrategyPatchPtrOutput) ToDaemonSetUpdateStrategyPatchPtr return o } +func (o DaemonSetUpdateStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategyPatch] { + return pulumix.Output[*DaemonSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetUpdateStrategyPatchPtrOutput) Elem() DaemonSetUpdateStrategyPatchOutput { return o.ApplyT(func(v *DaemonSetUpdateStrategyPatch) DaemonSetUpdateStrategyPatch { if v != nil { @@ -2372,6 +2661,12 @@ func (i DeploymentTypeArgs) ToDeploymentTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeOutput) } +func (i DeploymentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: i.ToDeploymentTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentTypeArrayInput is an input type that accepts DeploymentTypeArray and DeploymentTypeArrayOutput values. // You can construct a concrete instance of `DeploymentTypeArrayInput` via: // @@ -2397,6 +2692,12 @@ func (i DeploymentTypeArray) ToDeploymentTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeArrayOutput) } +func (i DeploymentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: i.ToDeploymentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -2434,6 +2735,12 @@ func (o DeploymentTypeOutput) ToDeploymentTypeOutputWithContext(ctx context.Cont return o } +func (o DeploymentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2473,6 +2780,12 @@ func (o DeploymentTypeArrayOutput) ToDeploymentTypeArrayOutputWithContext(ctx co return o } +func (o DeploymentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: o.OutputState, + } +} + func (o DeploymentTypeArrayOutput) Index(i pulumi.IntInput) DeploymentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentType { return vs[0].([]DeploymentType)[vs[1].(int)] @@ -2534,6 +2847,12 @@ func (i DeploymentConditionArgs) ToDeploymentConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionOutput) } +func (i DeploymentConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: i.ToDeploymentConditionOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionArrayInput is an input type that accepts DeploymentConditionArray and DeploymentConditionArrayOutput values. // You can construct a concrete instance of `DeploymentConditionArrayInput` via: // @@ -2559,6 +2878,12 @@ func (i DeploymentConditionArray) ToDeploymentConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionArrayOutput) } +func (i DeploymentConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: i.ToDeploymentConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionOutput struct{ *pulumi.OutputState } @@ -2574,6 +2899,12 @@ func (o DeploymentConditionOutput) ToDeploymentConditionOutputWithContext(ctx co return o } +func (o DeploymentConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2618,6 +2949,12 @@ func (o DeploymentConditionArrayOutput) ToDeploymentConditionArrayOutputWithCont return o } +func (o DeploymentConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionArrayOutput) Index(i pulumi.IntInput) DeploymentConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentCondition { return vs[0].([]DeploymentCondition)[vs[1].(int)] @@ -2679,6 +3016,12 @@ func (i DeploymentConditionPatchArgs) ToDeploymentConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchOutput) } +func (i DeploymentConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionPatchArrayInput is an input type that accepts DeploymentConditionPatchArray and DeploymentConditionPatchArrayOutput values. // You can construct a concrete instance of `DeploymentConditionPatchArrayInput` via: // @@ -2704,6 +3047,12 @@ func (i DeploymentConditionPatchArray) ToDeploymentConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchArrayOutput) } +func (i DeploymentConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionPatchOutput struct{ *pulumi.OutputState } @@ -2719,6 +3068,12 @@ func (o DeploymentConditionPatchOutput) ToDeploymentConditionPatchOutputWithCont return o } +func (o DeploymentConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2763,6 +3118,12 @@ func (o DeploymentConditionPatchArrayOutput) ToDeploymentConditionPatchArrayOutp return o } +func (o DeploymentConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionPatchArrayOutput) Index(i pulumi.IntInput) DeploymentConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentConditionPatch { return vs[0].([]DeploymentConditionPatch)[vs[1].(int)] @@ -2816,6 +3177,12 @@ func (i DeploymentListTypeArgs) ToDeploymentListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentListTypeOutput) } +func (i DeploymentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: i.ToDeploymentListTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentList is a list of Deployments. type DeploymentListTypeOutput struct{ *pulumi.OutputState } @@ -2831,6 +3198,12 @@ func (o DeploymentListTypeOutput) ToDeploymentListTypeOutputWithContext(ctx cont return o } +func (o DeploymentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2946,6 +3319,12 @@ func (i DeploymentPatchTypeArgs) ToDeploymentPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchTypeOutput) } +func (i DeploymentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: i.ToDeploymentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -2983,6 +3362,12 @@ func (o DeploymentPatchTypeOutput) ToDeploymentPatchTypeOutputWithContext(ctx co return o } +func (o DeploymentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3071,6 +3456,12 @@ func (i DeploymentSpecArgs) ToDeploymentSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecOutput) } +func (i DeploymentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: i.ToDeploymentSpecOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecArgs) ToDeploymentSpecPtrOutput() DeploymentSpecPtrOutput { return i.ToDeploymentSpecPtrOutputWithContext(context.Background()) } @@ -3112,6 +3503,12 @@ func (i *deploymentSpecPtrType) ToDeploymentSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPtrOutput) } +func (i *deploymentSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: i.ToDeploymentSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecOutput struct{ *pulumi.OutputState } @@ -3137,6 +3534,12 @@ func (o DeploymentSpecOutput) ToDeploymentSpecPtrOutputWithContext(ctx context.C }).(DeploymentSpecPtrOutput) } +func (o DeploymentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -3191,6 +3594,12 @@ func (o DeploymentSpecPtrOutput) ToDeploymentSpecPtrOutputWithContext(ctx contex return o } +func (o DeploymentSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPtrOutput) Elem() DeploymentSpecOutput { return o.ApplyT(func(v *DeploymentSpec) DeploymentSpec { if v != nil { @@ -3344,6 +3753,12 @@ func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchOutput) } +func (i DeploymentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchPtrOutput() DeploymentSpecPatchPtrOutput { return i.ToDeploymentSpecPatchPtrOutputWithContext(context.Background()) } @@ -3385,6 +3800,12 @@ func (i *deploymentSpecPatchPtrType) ToDeploymentSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchPtrOutput) } +func (i *deploymentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecPatchOutput struct{ *pulumi.OutputState } @@ -3410,6 +3831,12 @@ func (o DeploymentSpecPatchOutput) ToDeploymentSpecPatchPtrOutputWithContext(ctx }).(DeploymentSpecPatchPtrOutput) } +func (o DeploymentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -3464,6 +3891,12 @@ func (o DeploymentSpecPatchPtrOutput) ToDeploymentSpecPatchPtrOutputWithContext( return o } +func (o DeploymentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPatchPtrOutput) Elem() DeploymentSpecPatchOutput { return o.ApplyT(func(v *DeploymentSpecPatch) DeploymentSpecPatch { if v != nil { @@ -3617,6 +4050,12 @@ func (i DeploymentStatusArgs) ToDeploymentStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusOutput) } +func (i DeploymentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: i.ToDeploymentStatusOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusArgs) ToDeploymentStatusPtrOutput() DeploymentStatusPtrOutput { return i.ToDeploymentStatusPtrOutputWithContext(context.Background()) } @@ -3658,6 +4097,12 @@ func (i *deploymentStatusPtrType) ToDeploymentStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPtrOutput) } +func (i *deploymentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: i.ToDeploymentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusOutput struct{ *pulumi.OutputState } @@ -3683,6 +4128,12 @@ func (o DeploymentStatusOutput) ToDeploymentStatusPtrOutputWithContext(ctx conte }).(DeploymentStatusPtrOutput) } +func (o DeploymentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -3737,6 +4188,12 @@ func (o DeploymentStatusPtrOutput) ToDeploymentStatusPtrOutputWithContext(ctx co return o } +func (o DeploymentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPtrOutput) Elem() DeploymentStatusOutput { return o.ApplyT(func(v *DeploymentStatus) DeploymentStatus { if v != nil { @@ -3890,6 +4347,12 @@ func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchOutput) } +func (i DeploymentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchPtrOutput() DeploymentStatusPatchPtrOutput { return i.ToDeploymentStatusPatchPtrOutputWithContext(context.Background()) } @@ -3931,6 +4394,12 @@ func (i *deploymentStatusPatchPtrType) ToDeploymentStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchPtrOutput) } +func (i *deploymentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusPatchOutput struct{ *pulumi.OutputState } @@ -3956,6 +4425,12 @@ func (o DeploymentStatusPatchOutput) ToDeploymentStatusPatchPtrOutputWithContext }).(DeploymentStatusPatchPtrOutput) } +func (o DeploymentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -4010,6 +4485,12 @@ func (o DeploymentStatusPatchPtrOutput) ToDeploymentStatusPatchPtrOutputWithCont return o } +func (o DeploymentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPatchPtrOutput) Elem() DeploymentStatusPatchOutput { return o.ApplyT(func(v *DeploymentStatusPatch) DeploymentStatusPatch { if v != nil { @@ -4139,6 +4620,12 @@ func (i DeploymentStrategyArgs) ToDeploymentStrategyOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyOutput) } +func (i DeploymentStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyArgs) ToDeploymentStrategyPtrOutput() DeploymentStrategyPtrOutput { return i.ToDeploymentStrategyPtrOutputWithContext(context.Background()) } @@ -4180,6 +4667,12 @@ func (i *deploymentStrategyPtrType) ToDeploymentStrategyPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPtrOutput) } +func (i *deploymentStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyOutput struct{ *pulumi.OutputState } @@ -4205,6 +4698,12 @@ func (o DeploymentStrategyOutput) ToDeploymentStrategyPtrOutputWithContext(ctx c }).(DeploymentStrategyPtrOutput) } +func (o DeploymentStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyOutput) RollingUpdate() RollingUpdateDeploymentPtrOutput { return o.ApplyT(func(v DeploymentStrategy) *RollingUpdateDeployment { return v.RollingUpdate }).(RollingUpdateDeploymentPtrOutput) @@ -4229,6 +4728,12 @@ func (o DeploymentStrategyPtrOutput) ToDeploymentStrategyPtrOutputWithContext(ct return o } +func (o DeploymentStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPtrOutput) Elem() DeploymentStrategyOutput { return o.ApplyT(func(v *DeploymentStrategy) DeploymentStrategy { if v != nil { @@ -4298,6 +4803,12 @@ func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchOutput) } +func (i DeploymentStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchPtrOutput() DeploymentStrategyPatchPtrOutput { return i.ToDeploymentStrategyPatchPtrOutputWithContext(context.Background()) } @@ -4339,6 +4850,12 @@ func (i *deploymentStrategyPatchPtrType) ToDeploymentStrategyPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchPtrOutput) } +func (i *deploymentStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyPatchOutput struct{ *pulumi.OutputState } @@ -4364,6 +4881,12 @@ func (o DeploymentStrategyPatchOutput) ToDeploymentStrategyPatchPtrOutputWithCon }).(DeploymentStrategyPatchPtrOutput) } +func (o DeploymentStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyPatchOutput) RollingUpdate() RollingUpdateDeploymentPatchPtrOutput { return o.ApplyT(func(v DeploymentStrategyPatch) *RollingUpdateDeploymentPatch { return v.RollingUpdate }).(RollingUpdateDeploymentPatchPtrOutput) @@ -4388,6 +4911,12 @@ func (o DeploymentStrategyPatchPtrOutput) ToDeploymentStrategyPatchPtrOutputWith return o } +func (o DeploymentStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPatchPtrOutput) Elem() DeploymentStrategyPatchOutput { return o.ApplyT(func(v *DeploymentStrategyPatch) DeploymentStrategyPatch { if v != nil { @@ -4469,6 +4998,12 @@ func (i ReplicaSetTypeArgs) ToReplicaSetTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetTypeOutput) } +func (i ReplicaSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetType] { + return pulumix.Output[ReplicaSetType]{ + OutputState: i.ToReplicaSetTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetTypeArrayInput is an input type that accepts ReplicaSetTypeArray and ReplicaSetTypeArrayOutput values. // You can construct a concrete instance of `ReplicaSetTypeArrayInput` via: // @@ -4494,6 +5029,12 @@ func (i ReplicaSetTypeArray) ToReplicaSetTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetTypeArrayOutput) } +func (i ReplicaSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetType] { + return pulumix.Output[[]ReplicaSetType]{ + OutputState: i.ToReplicaSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSet ensures that a specified number of pod replicas are running at any given time. type ReplicaSetTypeOutput struct{ *pulumi.OutputState } @@ -4509,6 +5050,12 @@ func (o ReplicaSetTypeOutput) ToReplicaSetTypeOutputWithContext(ctx context.Cont return o } +func (o ReplicaSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetType] { + return pulumix.Output[ReplicaSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4548,6 +5095,12 @@ func (o ReplicaSetTypeArrayOutput) ToReplicaSetTypeArrayOutputWithContext(ctx co return o } +func (o ReplicaSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetType] { + return pulumix.Output[[]ReplicaSetType]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetTypeArrayOutput) Index(i pulumi.IntInput) ReplicaSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetType { return vs[0].([]ReplicaSetType)[vs[1].(int)] @@ -4605,6 +5158,12 @@ func (i ReplicaSetConditionArgs) ToReplicaSetConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionOutput) } +func (i ReplicaSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetCondition] { + return pulumix.Output[ReplicaSetCondition]{ + OutputState: i.ToReplicaSetConditionOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetConditionArrayInput is an input type that accepts ReplicaSetConditionArray and ReplicaSetConditionArrayOutput values. // You can construct a concrete instance of `ReplicaSetConditionArrayInput` via: // @@ -4630,6 +5189,12 @@ func (i ReplicaSetConditionArray) ToReplicaSetConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionArrayOutput) } +func (i ReplicaSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetCondition] { + return pulumix.Output[[]ReplicaSetCondition]{ + OutputState: i.ToReplicaSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetCondition describes the state of a replica set at a certain point. type ReplicaSetConditionOutput struct{ *pulumi.OutputState } @@ -4645,6 +5210,12 @@ func (o ReplicaSetConditionOutput) ToReplicaSetConditionOutputWithContext(ctx co return o } +func (o ReplicaSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetCondition] { + return pulumix.Output[ReplicaSetCondition]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicaSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -4684,6 +5255,12 @@ func (o ReplicaSetConditionArrayOutput) ToReplicaSetConditionArrayOutputWithCont return o } +func (o ReplicaSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetCondition] { + return pulumix.Output[[]ReplicaSetCondition]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetConditionArrayOutput) Index(i pulumi.IntInput) ReplicaSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetCondition { return vs[0].([]ReplicaSetCondition)[vs[1].(int)] @@ -4741,6 +5318,12 @@ func (i ReplicaSetConditionPatchArgs) ToReplicaSetConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionPatchOutput) } +func (i ReplicaSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetConditionPatch] { + return pulumix.Output[ReplicaSetConditionPatch]{ + OutputState: i.ToReplicaSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetConditionPatchArrayInput is an input type that accepts ReplicaSetConditionPatchArray and ReplicaSetConditionPatchArrayOutput values. // You can construct a concrete instance of `ReplicaSetConditionPatchArrayInput` via: // @@ -4766,6 +5349,12 @@ func (i ReplicaSetConditionPatchArray) ToReplicaSetConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionPatchArrayOutput) } +func (i ReplicaSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetConditionPatch] { + return pulumix.Output[[]ReplicaSetConditionPatch]{ + OutputState: i.ToReplicaSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetCondition describes the state of a replica set at a certain point. type ReplicaSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -4781,6 +5370,12 @@ func (o ReplicaSetConditionPatchOutput) ToReplicaSetConditionPatchOutputWithCont return o } +func (o ReplicaSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetConditionPatch] { + return pulumix.Output[ReplicaSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicaSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -4820,6 +5415,12 @@ func (o ReplicaSetConditionPatchArrayOutput) ToReplicaSetConditionPatchArrayOutp return o } +func (o ReplicaSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetConditionPatch] { + return pulumix.Output[[]ReplicaSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetConditionPatchArrayOutput) Index(i pulumi.IntInput) ReplicaSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetConditionPatch { return vs[0].([]ReplicaSetConditionPatch)[vs[1].(int)] @@ -4873,6 +5474,12 @@ func (i ReplicaSetListTypeArgs) ToReplicaSetListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListTypeOutput) } +func (i ReplicaSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetListType] { + return pulumix.Output[ReplicaSetListType]{ + OutputState: i.ToReplicaSetListTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetList is a collection of ReplicaSets. type ReplicaSetListTypeOutput struct{ *pulumi.OutputState } @@ -4888,6 +5495,12 @@ func (o ReplicaSetListTypeOutput) ToReplicaSetListTypeOutputWithContext(ctx cont return o } +func (o ReplicaSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetListType] { + return pulumix.Output[ReplicaSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4959,6 +5572,12 @@ func (i ReplicaSetPatchTypeArgs) ToReplicaSetPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchTypeOutput) } +func (i ReplicaSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetPatchType] { + return pulumix.Output[ReplicaSetPatchType]{ + OutputState: i.ToReplicaSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSet ensures that a specified number of pod replicas are running at any given time. type ReplicaSetPatchTypeOutput struct{ *pulumi.OutputState } @@ -4974,6 +5593,12 @@ func (o ReplicaSetPatchTypeOutput) ToReplicaSetPatchTypeOutputWithContext(ctx co return o } +func (o ReplicaSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetPatchType] { + return pulumix.Output[ReplicaSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5046,6 +5671,12 @@ func (i ReplicaSetSpecArgs) ToReplicaSetSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecOutput) } +func (i ReplicaSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpec] { + return pulumix.Output[ReplicaSetSpec]{ + OutputState: i.ToReplicaSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetSpecArgs) ToReplicaSetSpecPtrOutput() ReplicaSetSpecPtrOutput { return i.ToReplicaSetSpecPtrOutputWithContext(context.Background()) } @@ -5087,6 +5718,12 @@ func (i *replicaSetSpecPtrType) ToReplicaSetSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPtrOutput) } +func (i *replicaSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpec] { + return pulumix.Output[*ReplicaSetSpec]{ + OutputState: i.ToReplicaSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetSpec is the specification of a ReplicaSet. type ReplicaSetSpecOutput struct{ *pulumi.OutputState } @@ -5112,6 +5749,12 @@ func (o ReplicaSetSpecOutput) ToReplicaSetSpecPtrOutputWithContext(ctx context.C }).(ReplicaSetSpecPtrOutput) } +func (o ReplicaSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpec] { + return pulumix.Output[ReplicaSetSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicaSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -5146,6 +5789,12 @@ func (o ReplicaSetSpecPtrOutput) ToReplicaSetSpecPtrOutputWithContext(ctx contex return o } +func (o ReplicaSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpec] { + return pulumix.Output[*ReplicaSetSpec]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetSpecPtrOutput) Elem() ReplicaSetSpecOutput { return o.ApplyT(func(v *ReplicaSetSpec) ReplicaSetSpec { if v != nil { @@ -5243,6 +5892,12 @@ func (i ReplicaSetSpecPatchArgs) ToReplicaSetSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPatchOutput) } +func (i ReplicaSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpecPatch] { + return pulumix.Output[ReplicaSetSpecPatch]{ + OutputState: i.ToReplicaSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetSpecPatchArgs) ToReplicaSetSpecPatchPtrOutput() ReplicaSetSpecPatchPtrOutput { return i.ToReplicaSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -5284,6 +5939,12 @@ func (i *replicaSetSpecPatchPtrType) ToReplicaSetSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPatchPtrOutput) } +func (i *replicaSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpecPatch] { + return pulumix.Output[*ReplicaSetSpecPatch]{ + OutputState: i.ToReplicaSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetSpec is the specification of a ReplicaSet. type ReplicaSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -5309,6 +5970,12 @@ func (o ReplicaSetSpecPatchOutput) ToReplicaSetSpecPatchPtrOutputWithContext(ctx }).(ReplicaSetSpecPatchPtrOutput) } +func (o ReplicaSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpecPatch] { + return pulumix.Output[ReplicaSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicaSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -5343,6 +6010,12 @@ func (o ReplicaSetSpecPatchPtrOutput) ToReplicaSetSpecPatchPtrOutputWithContext( return o } +func (o ReplicaSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpecPatch] { + return pulumix.Output[*ReplicaSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetSpecPatchPtrOutput) Elem() ReplicaSetSpecPatchOutput { return o.ApplyT(func(v *ReplicaSetSpecPatch) ReplicaSetSpecPatch { if v != nil { @@ -5448,6 +6121,12 @@ func (i ReplicaSetStatusArgs) ToReplicaSetStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusOutput) } +func (i ReplicaSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatus] { + return pulumix.Output[ReplicaSetStatus]{ + OutputState: i.ToReplicaSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetStatusArgs) ToReplicaSetStatusPtrOutput() ReplicaSetStatusPtrOutput { return i.ToReplicaSetStatusPtrOutputWithContext(context.Background()) } @@ -5489,6 +6168,12 @@ func (i *replicaSetStatusPtrType) ToReplicaSetStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPtrOutput) } +func (i *replicaSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatus] { + return pulumix.Output[*ReplicaSetStatus]{ + OutputState: i.ToReplicaSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetStatus represents the current status of a ReplicaSet. type ReplicaSetStatusOutput struct{ *pulumi.OutputState } @@ -5514,6 +6199,12 @@ func (o ReplicaSetStatusOutput) ToReplicaSetStatusPtrOutputWithContext(ctx conte }).(ReplicaSetStatusPtrOutput) } +func (o ReplicaSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatus] { + return pulumix.Output[ReplicaSetStatus]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replica set. func (o ReplicaSetStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -5558,6 +6249,12 @@ func (o ReplicaSetStatusPtrOutput) ToReplicaSetStatusPtrOutputWithContext(ctx co return o } +func (o ReplicaSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatus] { + return pulumix.Output[*ReplicaSetStatus]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetStatusPtrOutput) Elem() ReplicaSetStatusOutput { return o.ApplyT(func(v *ReplicaSetStatus) ReplicaSetStatus { if v != nil { @@ -5683,6 +6380,12 @@ func (i ReplicaSetStatusPatchArgs) ToReplicaSetStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPatchOutput) } +func (i ReplicaSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatusPatch] { + return pulumix.Output[ReplicaSetStatusPatch]{ + OutputState: i.ToReplicaSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetStatusPatchArgs) ToReplicaSetStatusPatchPtrOutput() ReplicaSetStatusPatchPtrOutput { return i.ToReplicaSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -5724,6 +6427,12 @@ func (i *replicaSetStatusPatchPtrType) ToReplicaSetStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPatchPtrOutput) } +func (i *replicaSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatusPatch] { + return pulumix.Output[*ReplicaSetStatusPatch]{ + OutputState: i.ToReplicaSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetStatus represents the current status of a ReplicaSet. type ReplicaSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -5749,6 +6458,12 @@ func (o ReplicaSetStatusPatchOutput) ToReplicaSetStatusPatchPtrOutputWithContext }).(ReplicaSetStatusPatchPtrOutput) } +func (o ReplicaSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatusPatch] { + return pulumix.Output[ReplicaSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replica set. func (o ReplicaSetStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -5793,6 +6508,12 @@ func (o ReplicaSetStatusPatchPtrOutput) ToReplicaSetStatusPatchPtrOutputWithCont return o } +func (o ReplicaSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatusPatch] { + return pulumix.Output[*ReplicaSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetStatusPatchPtrOutput) Elem() ReplicaSetStatusPatchOutput { return o.ApplyT(func(v *ReplicaSetStatusPatch) ReplicaSetStatusPatch { if v != nil { @@ -5898,6 +6619,12 @@ func (i RollingUpdateDaemonSetArgs) ToRollingUpdateDaemonSetOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetOutput) } +func (i RollingUpdateDaemonSetArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSet] { + return pulumix.Output[RollingUpdateDaemonSet]{ + OutputState: i.ToRollingUpdateDaemonSetOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDaemonSetArgs) ToRollingUpdateDaemonSetPtrOutput() RollingUpdateDaemonSetPtrOutput { return i.ToRollingUpdateDaemonSetPtrOutputWithContext(context.Background()) } @@ -5939,6 +6666,12 @@ func (i *rollingUpdateDaemonSetPtrType) ToRollingUpdateDaemonSetPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPtrOutput) } +func (i *rollingUpdateDaemonSetPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSet] { + return pulumix.Output[*RollingUpdateDaemonSet]{ + OutputState: i.ToRollingUpdateDaemonSetPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of daemon set rolling update. type RollingUpdateDaemonSetOutput struct{ *pulumi.OutputState } @@ -5964,6 +6697,12 @@ func (o RollingUpdateDaemonSetOutput) ToRollingUpdateDaemonSetPtrOutputWithConte }).(RollingUpdateDaemonSetPtrOutput) } +func (o RollingUpdateDaemonSetOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSet] { + return pulumix.Output[RollingUpdateDaemonSet]{ + OutputState: o.OutputState, + } +} + // The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update. func (o RollingUpdateDaemonSetOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDaemonSet) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -5983,6 +6722,12 @@ func (o RollingUpdateDaemonSetPtrOutput) ToRollingUpdateDaemonSetPtrOutputWithCo return o } +func (o RollingUpdateDaemonSetPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSet] { + return pulumix.Output[*RollingUpdateDaemonSet]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDaemonSetPtrOutput) Elem() RollingUpdateDaemonSetOutput { return o.ApplyT(func(v *RollingUpdateDaemonSet) RollingUpdateDaemonSet { if v != nil { @@ -6038,6 +6783,12 @@ func (i RollingUpdateDaemonSetPatchArgs) ToRollingUpdateDaemonSetPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPatchOutput) } +func (i RollingUpdateDaemonSetPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSetPatch] { + return pulumix.Output[RollingUpdateDaemonSetPatch]{ + OutputState: i.ToRollingUpdateDaemonSetPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDaemonSetPatchArgs) ToRollingUpdateDaemonSetPatchPtrOutput() RollingUpdateDaemonSetPatchPtrOutput { return i.ToRollingUpdateDaemonSetPatchPtrOutputWithContext(context.Background()) } @@ -6079,6 +6830,12 @@ func (i *rollingUpdateDaemonSetPatchPtrType) ToRollingUpdateDaemonSetPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPatchPtrOutput) } +func (i *rollingUpdateDaemonSetPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSetPatch] { + return pulumix.Output[*RollingUpdateDaemonSetPatch]{ + OutputState: i.ToRollingUpdateDaemonSetPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of daemon set rolling update. type RollingUpdateDaemonSetPatchOutput struct{ *pulumi.OutputState } @@ -6104,6 +6861,12 @@ func (o RollingUpdateDaemonSetPatchOutput) ToRollingUpdateDaemonSetPatchPtrOutpu }).(RollingUpdateDaemonSetPatchPtrOutput) } +func (o RollingUpdateDaemonSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSetPatch] { + return pulumix.Output[RollingUpdateDaemonSetPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update. func (o RollingUpdateDaemonSetPatchOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDaemonSetPatch) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -6123,6 +6886,12 @@ func (o RollingUpdateDaemonSetPatchPtrOutput) ToRollingUpdateDaemonSetPatchPtrOu return o } +func (o RollingUpdateDaemonSetPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSetPatch] { + return pulumix.Output[*RollingUpdateDaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDaemonSetPatchPtrOutput) Elem() RollingUpdateDaemonSetPatchOutput { return o.ApplyT(func(v *RollingUpdateDaemonSetPatch) RollingUpdateDaemonSetPatch { if v != nil { @@ -6182,6 +6951,12 @@ func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentOutput) } +func (i RollingUpdateDeploymentArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentPtrOutput() RollingUpdateDeploymentPtrOutput { return i.ToRollingUpdateDeploymentPtrOutputWithContext(context.Background()) } @@ -6223,6 +6998,12 @@ func (i *rollingUpdateDeploymentPtrType) ToRollingUpdateDeploymentPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPtrOutput) } +func (i *rollingUpdateDeploymentPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentOutput struct{ *pulumi.OutputState } @@ -6248,6 +7029,12 @@ func (o RollingUpdateDeploymentOutput) ToRollingUpdateDeploymentPtrOutputWithCon }).(RollingUpdateDeploymentPtrOutput) } +func (o RollingUpdateDeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeployment) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -6272,6 +7059,12 @@ func (o RollingUpdateDeploymentPtrOutput) ToRollingUpdateDeploymentPtrOutputWith return o } +func (o RollingUpdateDeploymentPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPtrOutput) Elem() RollingUpdateDeploymentOutput { return o.ApplyT(func(v *RollingUpdateDeployment) RollingUpdateDeployment { if v != nil { @@ -6341,6 +7134,12 @@ func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchOutput) } +func (i RollingUpdateDeploymentPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchPtrOutput() RollingUpdateDeploymentPatchPtrOutput { return i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(context.Background()) } @@ -6382,6 +7181,12 @@ func (i *rollingUpdateDeploymentPatchPtrType) ToRollingUpdateDeploymentPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchPtrOutput) } +func (i *rollingUpdateDeploymentPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentPatchOutput struct{ *pulumi.OutputState } @@ -6407,6 +7212,12 @@ func (o RollingUpdateDeploymentPatchOutput) ToRollingUpdateDeploymentPatchPtrOut }).(RollingUpdateDeploymentPatchPtrOutput) } +func (o RollingUpdateDeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentPatchOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeploymentPatch) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -6431,6 +7242,12 @@ func (o RollingUpdateDeploymentPatchPtrOutput) ToRollingUpdateDeploymentPatchPtr return o } +func (o RollingUpdateDeploymentPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPatchPtrOutput) Elem() RollingUpdateDeploymentPatchOutput { return o.ApplyT(func(v *RollingUpdateDeploymentPatch) RollingUpdateDeploymentPatch { if v != nil { @@ -6496,6 +7313,12 @@ func (i RollingUpdateStatefulSetStrategyArgs) ToRollingUpdateStatefulSetStrategy return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyOutput) } +func (i RollingUpdateStatefulSetStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategy] { + return pulumix.Output[RollingUpdateStatefulSetStrategy]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateStatefulSetStrategyArgs) ToRollingUpdateStatefulSetStrategyPtrOutput() RollingUpdateStatefulSetStrategyPtrOutput { return i.ToRollingUpdateStatefulSetStrategyPtrOutputWithContext(context.Background()) } @@ -6537,6 +7360,12 @@ func (i *rollingUpdateStatefulSetStrategyPtrType) ToRollingUpdateStatefulSetStra return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPtrOutput) } +func (i *rollingUpdateStatefulSetStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategy] { + return pulumix.Output[*RollingUpdateStatefulSetStrategy]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. type RollingUpdateStatefulSetStrategyOutput struct{ *pulumi.OutputState } @@ -6562,6 +7391,12 @@ func (o RollingUpdateStatefulSetStrategyOutput) ToRollingUpdateStatefulSetStrate }).(RollingUpdateStatefulSetStrategyPtrOutput) } +func (o RollingUpdateStatefulSetStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategy] { + return pulumix.Output[RollingUpdateStatefulSetStrategy]{ + OutputState: o.OutputState, + } +} + // Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. func (o RollingUpdateStatefulSetStrategyOutput) Partition() pulumi.IntPtrOutput { return o.ApplyT(func(v RollingUpdateStatefulSetStrategy) *int { return v.Partition }).(pulumi.IntPtrOutput) @@ -6581,6 +7416,12 @@ func (o RollingUpdateStatefulSetStrategyPtrOutput) ToRollingUpdateStatefulSetStr return o } +func (o RollingUpdateStatefulSetStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategy] { + return pulumix.Output[*RollingUpdateStatefulSetStrategy]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateStatefulSetStrategyPtrOutput) Elem() RollingUpdateStatefulSetStrategyOutput { return o.ApplyT(func(v *RollingUpdateStatefulSetStrategy) RollingUpdateStatefulSetStrategy { if v != nil { @@ -6636,6 +7477,12 @@ func (i RollingUpdateStatefulSetStrategyPatchArgs) ToRollingUpdateStatefulSetStr return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPatchOutput) } +func (i RollingUpdateStatefulSetStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[RollingUpdateStatefulSetStrategyPatch]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateStatefulSetStrategyPatchArgs) ToRollingUpdateStatefulSetStrategyPatchPtrOutput() RollingUpdateStatefulSetStrategyPatchPtrOutput { return i.ToRollingUpdateStatefulSetStrategyPatchPtrOutputWithContext(context.Background()) } @@ -6677,6 +7524,12 @@ func (i *rollingUpdateStatefulSetStrategyPatchPtrType) ToRollingUpdateStatefulSe return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateStatefulSetStrategyPatchPtrOutput) } +func (i *rollingUpdateStatefulSetStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[*RollingUpdateStatefulSetStrategyPatch]{ + OutputState: i.ToRollingUpdateStatefulSetStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. type RollingUpdateStatefulSetStrategyPatchOutput struct{ *pulumi.OutputState } @@ -6702,6 +7555,12 @@ func (o RollingUpdateStatefulSetStrategyPatchOutput) ToRollingUpdateStatefulSetS }).(RollingUpdateStatefulSetStrategyPatchPtrOutput) } +func (o RollingUpdateStatefulSetStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[RollingUpdateStatefulSetStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. func (o RollingUpdateStatefulSetStrategyPatchOutput) Partition() pulumi.IntPtrOutput { return o.ApplyT(func(v RollingUpdateStatefulSetStrategyPatch) *int { return v.Partition }).(pulumi.IntPtrOutput) @@ -6721,6 +7580,12 @@ func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) ToRollingUpdateStatefulS return o } +func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateStatefulSetStrategyPatch] { + return pulumix.Output[*RollingUpdateStatefulSetStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateStatefulSetStrategyPatchPtrOutput) Elem() RollingUpdateStatefulSetStrategyPatchOutput { return o.ApplyT(func(v *RollingUpdateStatefulSetStrategyPatch) RollingUpdateStatefulSetStrategyPatch { if v != nil { @@ -6792,6 +7657,12 @@ func (i ScaleArgs) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return pulumi.ToOutputWithContext(ctx, i).(ScaleOutput) } +func (i ScaleArgs) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: i.ToScaleOutputWithContext(ctx).OutputState, + } +} + // Scale represents a scaling request for a resource. type ScaleOutput struct{ *pulumi.OutputState } @@ -6807,6 +7678,12 @@ func (o ScaleOutput) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return o } +func (o ScaleOutput) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScaleOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Scale) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6883,6 +7760,12 @@ func (i ScalePatchArgs) ToScalePatchOutputWithContext(ctx context.Context) Scale return pulumi.ToOutputWithContext(ctx, i).(ScalePatchOutput) } +func (i ScalePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: i.ToScalePatchOutputWithContext(ctx).OutputState, + } +} + // Scale represents a scaling request for a resource. type ScalePatchOutput struct{ *pulumi.OutputState } @@ -6898,6 +7781,12 @@ func (o ScalePatchOutput) ToScalePatchOutputWithContext(ctx context.Context) Sca return o } +func (o ScalePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScalePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ScalePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6958,6 +7847,12 @@ func (i ScaleSpecArgs) ToScaleSpecOutputWithContext(ctx context.Context) ScaleSp return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecOutput) } +func (i ScaleSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: i.ToScaleSpecOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecArgs) ToScaleSpecPtrOutput() ScaleSpecPtrOutput { return i.ToScaleSpecPtrOutputWithContext(context.Background()) } @@ -6999,6 +7894,12 @@ func (i *scaleSpecPtrType) ToScaleSpecPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPtrOutput) } +func (i *scaleSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: i.ToScaleSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleSpec describes the attributes of a scale subresource type ScaleSpecOutput struct{ *pulumi.OutputState } @@ -7024,6 +7925,12 @@ func (o ScaleSpecOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) Sc }).(ScaleSpecPtrOutput) } +func (o ScaleSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: o.OutputState, + } +} + // desired number of instances for the scaled object. func (o ScaleSpecOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpec) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -7043,6 +7950,12 @@ func (o ScaleSpecPtrOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) return o } +func (o ScaleSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPtrOutput) Elem() ScaleSpecOutput { return o.ApplyT(func(v *ScaleSpec) ScaleSpec { if v != nil { @@ -7098,6 +8011,12 @@ func (i ScaleSpecPatchArgs) ToScaleSpecPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchOutput) } +func (i ScaleSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecPatchArgs) ToScaleSpecPatchPtrOutput() ScaleSpecPatchPtrOutput { return i.ToScaleSpecPatchPtrOutputWithContext(context.Background()) } @@ -7139,6 +8058,12 @@ func (i *scaleSpecPatchPtrType) ToScaleSpecPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchPtrOutput) } +func (i *scaleSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleSpec describes the attributes of a scale subresource type ScaleSpecPatchOutput struct{ *pulumi.OutputState } @@ -7164,6 +8089,12 @@ func (o ScaleSpecPatchOutput) ToScaleSpecPatchPtrOutputWithContext(ctx context.C }).(ScaleSpecPatchPtrOutput) } +func (o ScaleSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + // desired number of instances for the scaled object. func (o ScaleSpecPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpecPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -7183,6 +8114,12 @@ func (o ScaleSpecPatchPtrOutput) ToScaleSpecPatchPtrOutputWithContext(ctx contex return o } +func (o ScaleSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPatchPtrOutput) Elem() ScaleSpecPatchOutput { return o.ApplyT(func(v *ScaleSpecPatch) ScaleSpecPatch { if v != nil { @@ -7246,6 +8183,12 @@ func (i ScaleStatusArgs) ToScaleStatusOutputWithContext(ctx context.Context) Sca return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusOutput) } +func (i ScaleStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: i.ToScaleStatusOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusArgs) ToScaleStatusPtrOutput() ScaleStatusPtrOutput { return i.ToScaleStatusPtrOutputWithContext(context.Background()) } @@ -7287,6 +8230,12 @@ func (i *scaleStatusPtrType) ToScaleStatusPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPtrOutput) } +func (i *scaleStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: i.ToScaleStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleStatus represents the current status of a scale subresource. type ScaleStatusOutput struct{ *pulumi.OutputState } @@ -7312,6 +8261,12 @@ func (o ScaleStatusOutput) ToScaleStatusPtrOutputWithContext(ctx context.Context }).(ScaleStatusPtrOutput) } +func (o ScaleStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: o.OutputState, + } +} + // actual number of observed instances of the scaled object. func (o ScaleStatusOutput) Replicas() pulumi.IntOutput { return o.ApplyT(func(v ScaleStatus) int { return v.Replicas }).(pulumi.IntOutput) @@ -7341,6 +8296,12 @@ func (o ScaleStatusPtrOutput) ToScaleStatusPtrOutputWithContext(ctx context.Cont return o } +func (o ScaleStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPtrOutput) Elem() ScaleStatusOutput { return o.ApplyT(func(v *ScaleStatus) ScaleStatus { if v != nil { @@ -7424,6 +8385,12 @@ func (i ScaleStatusPatchArgs) ToScaleStatusPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchOutput) } +func (i ScaleStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusPatchArgs) ToScaleStatusPatchPtrOutput() ScaleStatusPatchPtrOutput { return i.ToScaleStatusPatchPtrOutputWithContext(context.Background()) } @@ -7465,6 +8432,12 @@ func (i *scaleStatusPatchPtrType) ToScaleStatusPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchPtrOutput) } +func (i *scaleStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleStatus represents the current status of a scale subresource. type ScaleStatusPatchOutput struct{ *pulumi.OutputState } @@ -7490,6 +8463,12 @@ func (o ScaleStatusPatchOutput) ToScaleStatusPatchPtrOutputWithContext(ctx conte }).(ScaleStatusPatchPtrOutput) } +func (o ScaleStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + // actual number of observed instances of the scaled object. func (o ScaleStatusPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleStatusPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -7519,6 +8498,12 @@ func (o ScaleStatusPatchPtrOutput) ToScaleStatusPatchPtrOutputWithContext(ctx co return o } +func (o ScaleStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPatchPtrOutput) Elem() ScaleStatusPatchOutput { return o.ApplyT(func(v *ScaleStatusPatch) ScaleStatusPatch { if v != nil { @@ -7640,6 +8625,12 @@ func (i StatefulSetTypeArgs) ToStatefulSetTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetTypeOutput) } +func (i StatefulSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetType] { + return pulumix.Output[StatefulSetType]{ + OutputState: i.ToStatefulSetTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSetTypeArrayInput is an input type that accepts StatefulSetTypeArray and StatefulSetTypeArrayOutput values. // You can construct a concrete instance of `StatefulSetTypeArrayInput` via: // @@ -7665,6 +8656,12 @@ func (i StatefulSetTypeArray) ToStatefulSetTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetTypeArrayOutput) } +func (i StatefulSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetType] { + return pulumix.Output[[]StatefulSetType]{ + OutputState: i.ToStatefulSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSet represents a set of pods with consistent identities. Identities are defined as: // - Network: A single stable DNS and hostname. // - Storage: As many VolumeClaims as requested. @@ -7696,6 +8693,12 @@ func (o StatefulSetTypeOutput) ToStatefulSetTypeOutputWithContext(ctx context.Co return o } +func (o StatefulSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetType] { + return pulumix.Output[StatefulSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7734,6 +8737,12 @@ func (o StatefulSetTypeArrayOutput) ToStatefulSetTypeArrayOutputWithContext(ctx return o } +func (o StatefulSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetType] { + return pulumix.Output[[]StatefulSetType]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetTypeArrayOutput) Index(i pulumi.IntInput) StatefulSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetType { return vs[0].([]StatefulSetType)[vs[1].(int)] @@ -7791,6 +8800,12 @@ func (i StatefulSetConditionArgs) ToStatefulSetConditionOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionOutput) } +func (i StatefulSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetCondition] { + return pulumix.Output[StatefulSetCondition]{ + OutputState: i.ToStatefulSetConditionOutputWithContext(ctx).OutputState, + } +} + // StatefulSetConditionArrayInput is an input type that accepts StatefulSetConditionArray and StatefulSetConditionArrayOutput values. // You can construct a concrete instance of `StatefulSetConditionArrayInput` via: // @@ -7816,6 +8831,12 @@ func (i StatefulSetConditionArray) ToStatefulSetConditionArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionArrayOutput) } +func (i StatefulSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetCondition] { + return pulumix.Output[[]StatefulSetCondition]{ + OutputState: i.ToStatefulSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetCondition describes the state of a statefulset at a certain point. type StatefulSetConditionOutput struct{ *pulumi.OutputState } @@ -7831,6 +8852,12 @@ func (o StatefulSetConditionOutput) ToStatefulSetConditionOutputWithContext(ctx return o } +func (o StatefulSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetCondition] { + return pulumix.Output[StatefulSetCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o StatefulSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -7870,6 +8897,12 @@ func (o StatefulSetConditionArrayOutput) ToStatefulSetConditionArrayOutputWithCo return o } +func (o StatefulSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetCondition] { + return pulumix.Output[[]StatefulSetCondition]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetConditionArrayOutput) Index(i pulumi.IntInput) StatefulSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetCondition { return vs[0].([]StatefulSetCondition)[vs[1].(int)] @@ -7927,6 +8960,12 @@ func (i StatefulSetConditionPatchArgs) ToStatefulSetConditionPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionPatchOutput) } +func (i StatefulSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetConditionPatch] { + return pulumix.Output[StatefulSetConditionPatch]{ + OutputState: i.ToStatefulSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // StatefulSetConditionPatchArrayInput is an input type that accepts StatefulSetConditionPatchArray and StatefulSetConditionPatchArrayOutput values. // You can construct a concrete instance of `StatefulSetConditionPatchArrayInput` via: // @@ -7952,6 +8991,12 @@ func (i StatefulSetConditionPatchArray) ToStatefulSetConditionPatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(StatefulSetConditionPatchArrayOutput) } +func (i StatefulSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetConditionPatch] { + return pulumix.Output[[]StatefulSetConditionPatch]{ + OutputState: i.ToStatefulSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetCondition describes the state of a statefulset at a certain point. type StatefulSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -7967,6 +9012,12 @@ func (o StatefulSetConditionPatchOutput) ToStatefulSetConditionPatchOutputWithCo return o } +func (o StatefulSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetConditionPatch] { + return pulumix.Output[StatefulSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o StatefulSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -8006,6 +9057,12 @@ func (o StatefulSetConditionPatchArrayOutput) ToStatefulSetConditionPatchArrayOu return o } +func (o StatefulSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatefulSetConditionPatch] { + return pulumix.Output[[]StatefulSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetConditionPatchArrayOutput) Index(i pulumi.IntInput) StatefulSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatefulSetConditionPatch { return vs[0].([]StatefulSetConditionPatch)[vs[1].(int)] @@ -8055,6 +9112,12 @@ func (i StatefulSetListTypeArgs) ToStatefulSetListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListTypeOutput) } +func (i StatefulSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetListType] { + return pulumix.Output[StatefulSetListType]{ + OutputState: i.ToStatefulSetListTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSetList is a collection of StatefulSets. type StatefulSetListTypeOutput struct{ *pulumi.OutputState } @@ -8070,6 +9133,12 @@ func (o StatefulSetListTypeOutput) ToStatefulSetListTypeOutputWithContext(ctx co return o } +func (o StatefulSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetListType] { + return pulumix.Output[StatefulSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -8169,6 +9238,12 @@ func (i StatefulSetPatchTypeArgs) ToStatefulSetPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchTypeOutput) } +func (i StatefulSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPatchType] { + return pulumix.Output[StatefulSetPatchType]{ + OutputState: i.ToStatefulSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // StatefulSet represents a set of pods with consistent identities. Identities are defined as: // - Network: A single stable DNS and hostname. // - Storage: As many VolumeClaims as requested. @@ -8200,6 +9275,12 @@ func (o StatefulSetPatchTypeOutput) ToStatefulSetPatchTypeOutputWithContext(ctx return o } +func (o StatefulSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetPatchType] { + return pulumix.Output[StatefulSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -8287,6 +9368,12 @@ func (i StatefulSetSpecArgs) ToStatefulSetSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecOutput) } +func (i StatefulSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpec] { + return pulumix.Output[StatefulSetSpec]{ + OutputState: i.ToStatefulSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetSpecArgs) ToStatefulSetSpecPtrOutput() StatefulSetSpecPtrOutput { return i.ToStatefulSetSpecPtrOutputWithContext(context.Background()) } @@ -8328,6 +9415,12 @@ func (i *statefulSetSpecPtrType) ToStatefulSetSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPtrOutput) } +func (i *statefulSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpec] { + return pulumix.Output[*StatefulSetSpec]{ + OutputState: i.ToStatefulSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpecOutput struct{ *pulumi.OutputState } @@ -8353,6 +9446,12 @@ func (o StatefulSetSpecOutput) ToStatefulSetSpecPtrOutputWithContext(ctx context }).(StatefulSetSpecPtrOutput) } +func (o StatefulSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpec] { + return pulumix.Output[StatefulSetSpec]{ + OutputState: o.OutputState, + } +} + // podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. func (o StatefulSetSpecOutput) PodManagementPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetSpec) *string { return v.PodManagementPolicy }).(pulumi.StringPtrOutput) @@ -8407,6 +9506,12 @@ func (o StatefulSetSpecPtrOutput) ToStatefulSetSpecPtrOutputWithContext(ctx cont return o } +func (o StatefulSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpec] { + return pulumix.Output[*StatefulSetSpec]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetSpecPtrOutput) Elem() StatefulSetSpecOutput { return o.ApplyT(func(v *StatefulSetSpec) StatefulSetSpec { if v != nil { @@ -8560,6 +9665,12 @@ func (i StatefulSetSpecPatchArgs) ToStatefulSetSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPatchOutput) } +func (i StatefulSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpecPatch] { + return pulumix.Output[StatefulSetSpecPatch]{ + OutputState: i.ToStatefulSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetSpecPatchArgs) ToStatefulSetSpecPatchPtrOutput() StatefulSetSpecPatchPtrOutput { return i.ToStatefulSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -8601,6 +9712,12 @@ func (i *statefulSetSpecPatchPtrType) ToStatefulSetSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(StatefulSetSpecPatchPtrOutput) } +func (i *statefulSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpecPatch] { + return pulumix.Output[*StatefulSetSpecPatch]{ + OutputState: i.ToStatefulSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -8626,6 +9743,12 @@ func (o StatefulSetSpecPatchOutput) ToStatefulSetSpecPatchPtrOutputWithContext(c }).(StatefulSetSpecPatchPtrOutput) } +func (o StatefulSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetSpecPatch] { + return pulumix.Output[StatefulSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. func (o StatefulSetSpecPatchOutput) PodManagementPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v StatefulSetSpecPatch) *string { return v.PodManagementPolicy }).(pulumi.StringPtrOutput) @@ -8680,6 +9803,12 @@ func (o StatefulSetSpecPatchPtrOutput) ToStatefulSetSpecPatchPtrOutputWithContex return o } +func (o StatefulSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetSpecPatch] { + return pulumix.Output[*StatefulSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetSpecPatchPtrOutput) Elem() StatefulSetSpecPatchOutput { return o.ApplyT(func(v *StatefulSetSpecPatch) StatefulSetSpecPatch { if v != nil { @@ -8837,6 +9966,12 @@ func (i StatefulSetStatusArgs) ToStatefulSetStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusOutput) } +func (i StatefulSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatus] { + return pulumix.Output[StatefulSetStatus]{ + OutputState: i.ToStatefulSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetStatusArgs) ToStatefulSetStatusPtrOutput() StatefulSetStatusPtrOutput { return i.ToStatefulSetStatusPtrOutputWithContext(context.Background()) } @@ -8878,6 +10013,12 @@ func (i *statefulSetStatusPtrType) ToStatefulSetStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPtrOutput) } +func (i *statefulSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatus] { + return pulumix.Output[*StatefulSetStatus]{ + OutputState: i.ToStatefulSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetStatus represents the current state of a StatefulSet. type StatefulSetStatusOutput struct{ *pulumi.OutputState } @@ -8903,6 +10044,12 @@ func (o StatefulSetStatusOutput) ToStatefulSetStatusPtrOutputWithContext(ctx con }).(StatefulSetStatusPtrOutput) } +func (o StatefulSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatus] { + return pulumix.Output[StatefulSetStatus]{ + OutputState: o.OutputState, + } +} + // collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o StatefulSetStatusOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetStatus) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -8962,6 +10109,12 @@ func (o StatefulSetStatusPtrOutput) ToStatefulSetStatusPtrOutputWithContext(ctx return o } +func (o StatefulSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatus] { + return pulumix.Output[*StatefulSetStatus]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetStatusPtrOutput) Elem() StatefulSetStatusOutput { return o.ApplyT(func(v *StatefulSetStatus) StatefulSetStatus { if v != nil { @@ -9129,6 +10282,12 @@ func (i StatefulSetStatusPatchArgs) ToStatefulSetStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPatchOutput) } +func (i StatefulSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatusPatch] { + return pulumix.Output[StatefulSetStatusPatch]{ + OutputState: i.ToStatefulSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetStatusPatchArgs) ToStatefulSetStatusPatchPtrOutput() StatefulSetStatusPatchPtrOutput { return i.ToStatefulSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -9170,6 +10329,12 @@ func (i *statefulSetStatusPatchPtrType) ToStatefulSetStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(StatefulSetStatusPatchPtrOutput) } +func (i *statefulSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatusPatch] { + return pulumix.Output[*StatefulSetStatusPatch]{ + OutputState: i.ToStatefulSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetStatus represents the current state of a StatefulSet. type StatefulSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -9195,6 +10360,12 @@ func (o StatefulSetStatusPatchOutput) ToStatefulSetStatusPatchPtrOutputWithConte }).(StatefulSetStatusPatchPtrOutput) } +func (o StatefulSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetStatusPatch] { + return pulumix.Output[StatefulSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o StatefulSetStatusPatchOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v StatefulSetStatusPatch) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -9254,6 +10425,12 @@ func (o StatefulSetStatusPatchPtrOutput) ToStatefulSetStatusPatchPtrOutputWithCo return o } +func (o StatefulSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetStatusPatch] { + return pulumix.Output[*StatefulSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetStatusPatchPtrOutput) Elem() StatefulSetStatusPatchOutput { return o.ApplyT(func(v *StatefulSetStatusPatch) StatefulSetStatusPatch { if v != nil { @@ -9393,6 +10570,12 @@ func (i StatefulSetUpdateStrategyArgs) ToStatefulSetUpdateStrategyOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyOutput) } +func (i StatefulSetUpdateStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategy] { + return pulumix.Output[StatefulSetUpdateStrategy]{ + OutputState: i.ToStatefulSetUpdateStrategyOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetUpdateStrategyArgs) ToStatefulSetUpdateStrategyPtrOutput() StatefulSetUpdateStrategyPtrOutput { return i.ToStatefulSetUpdateStrategyPtrOutputWithContext(context.Background()) } @@ -9434,6 +10617,12 @@ func (i *statefulSetUpdateStrategyPtrType) ToStatefulSetUpdateStrategyPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPtrOutput) } +func (i *statefulSetUpdateStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategy] { + return pulumix.Output[*StatefulSetUpdateStrategy]{ + OutputState: i.ToStatefulSetUpdateStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. type StatefulSetUpdateStrategyOutput struct{ *pulumi.OutputState } @@ -9459,6 +10648,12 @@ func (o StatefulSetUpdateStrategyOutput) ToStatefulSetUpdateStrategyPtrOutputWit }).(StatefulSetUpdateStrategyPtrOutput) } +func (o StatefulSetUpdateStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategy] { + return pulumix.Output[StatefulSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. func (o StatefulSetUpdateStrategyOutput) RollingUpdate() RollingUpdateStatefulSetStrategyPtrOutput { return o.ApplyT(func(v StatefulSetUpdateStrategy) *RollingUpdateStatefulSetStrategy { return v.RollingUpdate }).(RollingUpdateStatefulSetStrategyPtrOutput) @@ -9483,6 +10678,12 @@ func (o StatefulSetUpdateStrategyPtrOutput) ToStatefulSetUpdateStrategyPtrOutput return o } +func (o StatefulSetUpdateStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategy] { + return pulumix.Output[*StatefulSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetUpdateStrategyPtrOutput) Elem() StatefulSetUpdateStrategyOutput { return o.ApplyT(func(v *StatefulSetUpdateStrategy) StatefulSetUpdateStrategy { if v != nil { @@ -9552,6 +10753,12 @@ func (i StatefulSetUpdateStrategyPatchArgs) ToStatefulSetUpdateStrategyPatchOutp return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPatchOutput) } +func (i StatefulSetUpdateStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategyPatch] { + return pulumix.Output[StatefulSetUpdateStrategyPatch]{ + OutputState: i.ToStatefulSetUpdateStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatefulSetUpdateStrategyPatchArgs) ToStatefulSetUpdateStrategyPatchPtrOutput() StatefulSetUpdateStrategyPatchPtrOutput { return i.ToStatefulSetUpdateStrategyPatchPtrOutputWithContext(context.Background()) } @@ -9593,6 +10800,12 @@ func (i *statefulSetUpdateStrategyPatchPtrType) ToStatefulSetUpdateStrategyPatch return pulumi.ToOutputWithContext(ctx, i).(StatefulSetUpdateStrategyPatchPtrOutput) } +func (i *statefulSetUpdateStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategyPatch] { + return pulumix.Output[*StatefulSetUpdateStrategyPatch]{ + OutputState: i.ToStatefulSetUpdateStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. type StatefulSetUpdateStrategyPatchOutput struct{ *pulumi.OutputState } @@ -9618,6 +10831,12 @@ func (o StatefulSetUpdateStrategyPatchOutput) ToStatefulSetUpdateStrategyPatchPt }).(StatefulSetUpdateStrategyPatchPtrOutput) } +func (o StatefulSetUpdateStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatefulSetUpdateStrategyPatch] { + return pulumix.Output[StatefulSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. func (o StatefulSetUpdateStrategyPatchOutput) RollingUpdate() RollingUpdateStatefulSetStrategyPatchPtrOutput { return o.ApplyT(func(v StatefulSetUpdateStrategyPatch) *RollingUpdateStatefulSetStrategyPatch { return v.RollingUpdate }).(RollingUpdateStatefulSetStrategyPatchPtrOutput) @@ -9642,6 +10861,12 @@ func (o StatefulSetUpdateStrategyPatchPtrOutput) ToStatefulSetUpdateStrategyPatc return o } +func (o StatefulSetUpdateStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetUpdateStrategyPatch] { + return pulumix.Output[*StatefulSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetUpdateStrategyPatchPtrOutput) Elem() StatefulSetUpdateStrategyPatchOutput { return o.ApplyT(func(v *StatefulSetUpdateStrategyPatch) StatefulSetUpdateStrategyPatch { if v != nil { diff --git a/sdk/go/kubernetes/apps/v1beta2/replicaSet.go b/sdk/go/kubernetes/apps/v1beta2/replicaSet.go index bea5ef0cbb..313bb7061c 100644 --- a/sdk/go/kubernetes/apps/v1beta2/replicaSet.go +++ b/sdk/go/kubernetes/apps/v1beta2/replicaSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicaSet ensures that a specified number of pod replicas are running at any given time. @@ -126,6 +127,12 @@ func (i *ReplicaSet) ToReplicaSetOutputWithContext(ctx context.Context) ReplicaS return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetOutput) } +func (i *ReplicaSet) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSet] { + return pulumix.Output[*ReplicaSet]{ + OutputState: i.ToReplicaSetOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetArrayInput is an input type that accepts ReplicaSetArray and ReplicaSetArrayOutput values. // You can construct a concrete instance of `ReplicaSetArrayInput` via: // @@ -151,6 +158,12 @@ func (i ReplicaSetArray) ToReplicaSetArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetArrayOutput) } +func (i ReplicaSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSet] { + return pulumix.Output[[]*ReplicaSet]{ + OutputState: i.ToReplicaSetArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetMapInput is an input type that accepts ReplicaSetMap and ReplicaSetMapOutput values. // You can construct a concrete instance of `ReplicaSetMapInput` via: // @@ -176,6 +189,12 @@ func (i ReplicaSetMap) ToReplicaSetMapOutputWithContext(ctx context.Context) Rep return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetMapOutput) } +func (i ReplicaSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSet] { + return pulumix.Output[map[string]*ReplicaSet]{ + OutputState: i.ToReplicaSetMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetOutput struct{ *pulumi.OutputState } func (ReplicaSetOutput) ElementType() reflect.Type { @@ -190,6 +209,12 @@ func (o ReplicaSetOutput) ToReplicaSetOutputWithContext(ctx context.Context) Rep return o } +func (o ReplicaSetOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSet] { + return pulumix.Output[*ReplicaSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicaSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -229,6 +254,12 @@ func (o ReplicaSetArrayOutput) ToReplicaSetArrayOutputWithContext(ctx context.Co return o } +func (o ReplicaSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSet] { + return pulumix.Output[[]*ReplicaSet]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetArrayOutput) Index(i pulumi.IntInput) ReplicaSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSet { return vs[0].([]*ReplicaSet)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o ReplicaSetMapOutput) ToReplicaSetMapOutputWithContext(ctx context.Contex return o } +func (o ReplicaSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSet] { + return pulumix.Output[map[string]*ReplicaSet]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSet { return vs[0].(map[string]*ReplicaSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/replicaSetList.go b/sdk/go/kubernetes/apps/v1beta2/replicaSetList.go index c6bac93e4e..30e779a3da 100644 --- a/sdk/go/kubernetes/apps/v1beta2/replicaSetList.go +++ b/sdk/go/kubernetes/apps/v1beta2/replicaSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicaSetList is a collection of ReplicaSets. @@ -117,6 +118,12 @@ func (i *ReplicaSetList) ToReplicaSetListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListOutput) } +func (i *ReplicaSetList) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetList] { + return pulumix.Output[*ReplicaSetList]{ + OutputState: i.ToReplicaSetListOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetListArrayInput is an input type that accepts ReplicaSetListArray and ReplicaSetListArrayOutput values. // You can construct a concrete instance of `ReplicaSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ReplicaSetListArray) ToReplicaSetListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListArrayOutput) } +func (i ReplicaSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetList] { + return pulumix.Output[[]*ReplicaSetList]{ + OutputState: i.ToReplicaSetListArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetListMapInput is an input type that accepts ReplicaSetListMap and ReplicaSetListMapOutput values. // You can construct a concrete instance of `ReplicaSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i ReplicaSetListMap) ToReplicaSetListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListMapOutput) } +func (i ReplicaSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetList] { + return pulumix.Output[map[string]*ReplicaSetList]{ + OutputState: i.ToReplicaSetListMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetListOutput struct{ *pulumi.OutputState } func (ReplicaSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ReplicaSetListOutput) ToReplicaSetListOutputWithContext(ctx context.Cont return o } +func (o ReplicaSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetList] { + return pulumix.Output[*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicaSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ReplicaSetListArrayOutput) ToReplicaSetListArrayOutputWithContext(ctx co return o } +func (o ReplicaSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetList] { + return pulumix.Output[[]*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetListArrayOutput) Index(i pulumi.IntInput) ReplicaSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSetList { return vs[0].([]*ReplicaSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ReplicaSetListMapOutput) ToReplicaSetListMapOutputWithContext(ctx contex return o } +func (o ReplicaSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetList] { + return pulumix.Output[map[string]*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetListMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSetList { return vs[0].(map[string]*ReplicaSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/replicaSetPatch.go b/sdk/go/kubernetes/apps/v1beta2/replicaSetPatch.go index 36e43fa67d..8773c99faf 100644 --- a/sdk/go/kubernetes/apps/v1beta2/replicaSetPatch.go +++ b/sdk/go/kubernetes/apps/v1beta2/replicaSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *ReplicaSetPatch) ToReplicaSetPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchOutput) } +func (i *ReplicaSetPatch) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetPatch] { + return pulumix.Output[*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetPatchArrayInput is an input type that accepts ReplicaSetPatchArray and ReplicaSetPatchArrayOutput values. // You can construct a concrete instance of `ReplicaSetPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i ReplicaSetPatchArray) ToReplicaSetPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchArrayOutput) } +func (i ReplicaSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetPatch] { + return pulumix.Output[[]*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetPatchMapInput is an input type that accepts ReplicaSetPatchMap and ReplicaSetPatchMapOutput values. // You can construct a concrete instance of `ReplicaSetPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i ReplicaSetPatchMap) ToReplicaSetPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchMapOutput) } +func (i ReplicaSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetPatch] { + return pulumix.Output[map[string]*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetPatchOutput struct{ *pulumi.OutputState } func (ReplicaSetPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o ReplicaSetPatchOutput) ToReplicaSetPatchOutputWithContext(ctx context.Co return o } +func (o ReplicaSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetPatch] { + return pulumix.Output[*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ReplicaSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o ReplicaSetPatchArrayOutput) ToReplicaSetPatchArrayOutputWithContext(ctx return o } +func (o ReplicaSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetPatch] { + return pulumix.Output[[]*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetPatchArrayOutput) Index(i pulumi.IntInput) ReplicaSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSetPatch { return vs[0].([]*ReplicaSetPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o ReplicaSetPatchMapOutput) ToReplicaSetPatchMapOutputWithContext(ctx cont return o } +func (o ReplicaSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetPatch] { + return pulumix.Output[map[string]*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetPatchMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSetPatch { return vs[0].(map[string]*ReplicaSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/statefulSet.go b/sdk/go/kubernetes/apps/v1beta2/statefulSet.go index 53c47acc10..0212cea9e9 100644 --- a/sdk/go/kubernetes/apps/v1beta2/statefulSet.go +++ b/sdk/go/kubernetes/apps/v1beta2/statefulSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StatefulSet represents a set of pods with consistent identities. Identities are defined as: @@ -139,6 +140,12 @@ func (i *StatefulSet) ToStatefulSetOutputWithContext(ctx context.Context) Statef return pulumi.ToOutputWithContext(ctx, i).(StatefulSetOutput) } +func (i *StatefulSet) ToOutput(ctx context.Context) pulumix.Output[*StatefulSet] { + return pulumix.Output[*StatefulSet]{ + OutputState: i.ToStatefulSetOutputWithContext(ctx).OutputState, + } +} + // StatefulSetArrayInput is an input type that accepts StatefulSetArray and StatefulSetArrayOutput values. // You can construct a concrete instance of `StatefulSetArrayInput` via: // @@ -164,6 +171,12 @@ func (i StatefulSetArray) ToStatefulSetArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetArrayOutput) } +func (i StatefulSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSet] { + return pulumix.Output[[]*StatefulSet]{ + OutputState: i.ToStatefulSetArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetMapInput is an input type that accepts StatefulSetMap and StatefulSetMapOutput values. // You can construct a concrete instance of `StatefulSetMapInput` via: // @@ -189,6 +202,12 @@ func (i StatefulSetMap) ToStatefulSetMapOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(StatefulSetMapOutput) } +func (i StatefulSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSet] { + return pulumix.Output[map[string]*StatefulSet]{ + OutputState: i.ToStatefulSetMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetOutput struct{ *pulumi.OutputState } func (StatefulSetOutput) ElementType() reflect.Type { @@ -203,6 +222,12 @@ func (o StatefulSetOutput) ToStatefulSetOutputWithContext(ctx context.Context) S return o } +func (o StatefulSetOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSet] { + return pulumix.Output[*StatefulSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StatefulSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -241,6 +266,12 @@ func (o StatefulSetArrayOutput) ToStatefulSetArrayOutputWithContext(ctx context. return o } +func (o StatefulSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSet] { + return pulumix.Output[[]*StatefulSet]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetArrayOutput) Index(i pulumi.IntInput) StatefulSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSet { return vs[0].([]*StatefulSet)[vs[1].(int)] @@ -261,6 +292,12 @@ func (o StatefulSetMapOutput) ToStatefulSetMapOutputWithContext(ctx context.Cont return o } +func (o StatefulSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSet] { + return pulumix.Output[map[string]*StatefulSet]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetMapOutput) MapIndex(k pulumi.StringInput) StatefulSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSet { return vs[0].(map[string]*StatefulSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/statefulSetList.go b/sdk/go/kubernetes/apps/v1beta2/statefulSetList.go index 0424c148e1..cab8bd5d21 100644 --- a/sdk/go/kubernetes/apps/v1beta2/statefulSetList.go +++ b/sdk/go/kubernetes/apps/v1beta2/statefulSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StatefulSetList is a collection of StatefulSets. @@ -111,6 +112,12 @@ func (i *StatefulSetList) ToStatefulSetListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListOutput) } +func (i *StatefulSetList) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetList] { + return pulumix.Output[*StatefulSetList]{ + OutputState: i.ToStatefulSetListOutputWithContext(ctx).OutputState, + } +} + // StatefulSetListArrayInput is an input type that accepts StatefulSetListArray and StatefulSetListArrayOutput values. // You can construct a concrete instance of `StatefulSetListArrayInput` via: // @@ -136,6 +143,12 @@ func (i StatefulSetListArray) ToStatefulSetListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListArrayOutput) } +func (i StatefulSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetList] { + return pulumix.Output[[]*StatefulSetList]{ + OutputState: i.ToStatefulSetListArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetListMapInput is an input type that accepts StatefulSetListMap and StatefulSetListMapOutput values. // You can construct a concrete instance of `StatefulSetListMapInput` via: // @@ -161,6 +174,12 @@ func (i StatefulSetListMap) ToStatefulSetListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StatefulSetListMapOutput) } +func (i StatefulSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetList] { + return pulumix.Output[map[string]*StatefulSetList]{ + OutputState: i.ToStatefulSetListMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetListOutput struct{ *pulumi.OutputState } func (StatefulSetListOutput) ElementType() reflect.Type { @@ -175,6 +194,12 @@ func (o StatefulSetListOutput) ToStatefulSetListOutputWithContext(ctx context.Co return o } +func (o StatefulSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetList] { + return pulumix.Output[*StatefulSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StatefulSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -207,6 +232,12 @@ func (o StatefulSetListArrayOutput) ToStatefulSetListArrayOutputWithContext(ctx return o } +func (o StatefulSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetList] { + return pulumix.Output[[]*StatefulSetList]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetListArrayOutput) Index(i pulumi.IntInput) StatefulSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSetList { return vs[0].([]*StatefulSetList)[vs[1].(int)] @@ -227,6 +258,12 @@ func (o StatefulSetListMapOutput) ToStatefulSetListMapOutputWithContext(ctx cont return o } +func (o StatefulSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetList] { + return pulumix.Output[map[string]*StatefulSetList]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetListMapOutput) MapIndex(k pulumi.StringInput) StatefulSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSetList { return vs[0].(map[string]*StatefulSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/apps/v1beta2/statefulSetPatch.go b/sdk/go/kubernetes/apps/v1beta2/statefulSetPatch.go index 4ca9e346d7..1c167f5b5e 100644 --- a/sdk/go/kubernetes/apps/v1beta2/statefulSetPatch.go +++ b/sdk/go/kubernetes/apps/v1beta2/statefulSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -145,6 +146,12 @@ func (i *StatefulSetPatch) ToStatefulSetPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchOutput) } +func (i *StatefulSetPatch) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPatch] { + return pulumix.Output[*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPatchArrayInput is an input type that accepts StatefulSetPatchArray and StatefulSetPatchArrayOutput values. // You can construct a concrete instance of `StatefulSetPatchArrayInput` via: // @@ -170,6 +177,12 @@ func (i StatefulSetPatchArray) ToStatefulSetPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchArrayOutput) } +func (i StatefulSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetPatch] { + return pulumix.Output[[]*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatefulSetPatchMapInput is an input type that accepts StatefulSetPatchMap and StatefulSetPatchMapOutput values. // You can construct a concrete instance of `StatefulSetPatchMapInput` via: // @@ -195,6 +208,12 @@ func (i StatefulSetPatchMap) ToStatefulSetPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StatefulSetPatchMapOutput) } +func (i StatefulSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetPatch] { + return pulumix.Output[map[string]*StatefulSetPatch]{ + OutputState: i.ToStatefulSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type StatefulSetPatchOutput struct{ *pulumi.OutputState } func (StatefulSetPatchOutput) ElementType() reflect.Type { @@ -209,6 +228,12 @@ func (o StatefulSetPatchOutput) ToStatefulSetPatchOutputWithContext(ctx context. return o } +func (o StatefulSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*StatefulSetPatch] { + return pulumix.Output[*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatefulSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *StatefulSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -247,6 +272,12 @@ func (o StatefulSetPatchArrayOutput) ToStatefulSetPatchArrayOutputWithContext(ct return o } +func (o StatefulSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatefulSetPatch] { + return pulumix.Output[[]*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPatchArrayOutput) Index(i pulumi.IntInput) StatefulSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatefulSetPatch { return vs[0].([]*StatefulSetPatch)[vs[1].(int)] @@ -267,6 +298,12 @@ func (o StatefulSetPatchMapOutput) ToStatefulSetPatchMapOutputWithContext(ctx co return o } +func (o StatefulSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatefulSetPatch] { + return pulumix.Output[map[string]*StatefulSetPatch]{ + OutputState: o.OutputState, + } +} + func (o StatefulSetPatchMapOutput) MapIndex(k pulumi.StringInput) StatefulSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatefulSetPatch { return vs[0].(map[string]*StatefulSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/auditregistration/v1alpha1/auditSink.go b/sdk/go/kubernetes/auditregistration/v1alpha1/auditSink.go index b2244186e0..262a85c0dd 100644 --- a/sdk/go/kubernetes/auditregistration/v1alpha1/auditSink.go +++ b/sdk/go/kubernetes/auditregistration/v1alpha1/auditSink.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // AuditSink represents a cluster level audit sink @@ -110,6 +111,12 @@ func (i *AuditSink) ToAuditSinkOutputWithContext(ctx context.Context) AuditSinkO return pulumi.ToOutputWithContext(ctx, i).(AuditSinkOutput) } +func (i *AuditSink) ToOutput(ctx context.Context) pulumix.Output[*AuditSink] { + return pulumix.Output[*AuditSink]{ + OutputState: i.ToAuditSinkOutputWithContext(ctx).OutputState, + } +} + // AuditSinkArrayInput is an input type that accepts AuditSinkArray and AuditSinkArrayOutput values. // You can construct a concrete instance of `AuditSinkArrayInput` via: // @@ -135,6 +142,12 @@ func (i AuditSinkArray) ToAuditSinkArrayOutputWithContext(ctx context.Context) A return pulumi.ToOutputWithContext(ctx, i).(AuditSinkArrayOutput) } +func (i AuditSinkArray) ToOutput(ctx context.Context) pulumix.Output[[]*AuditSink] { + return pulumix.Output[[]*AuditSink]{ + OutputState: i.ToAuditSinkArrayOutputWithContext(ctx).OutputState, + } +} + // AuditSinkMapInput is an input type that accepts AuditSinkMap and AuditSinkMapOutput values. // You can construct a concrete instance of `AuditSinkMapInput` via: // @@ -160,6 +173,12 @@ func (i AuditSinkMap) ToAuditSinkMapOutputWithContext(ctx context.Context) Audit return pulumi.ToOutputWithContext(ctx, i).(AuditSinkMapOutput) } +func (i AuditSinkMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AuditSink] { + return pulumix.Output[map[string]*AuditSink]{ + OutputState: i.ToAuditSinkMapOutputWithContext(ctx).OutputState, + } +} + type AuditSinkOutput struct{ *pulumi.OutputState } func (AuditSinkOutput) ElementType() reflect.Type { @@ -174,6 +193,12 @@ func (o AuditSinkOutput) ToAuditSinkOutputWithContext(ctx context.Context) Audit return o } +func (o AuditSinkOutput) ToOutput(ctx context.Context) pulumix.Output[*AuditSink] { + return pulumix.Output[*AuditSink]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o AuditSinkOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *AuditSink) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -207,6 +232,12 @@ func (o AuditSinkArrayOutput) ToAuditSinkArrayOutputWithContext(ctx context.Cont return o } +func (o AuditSinkArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AuditSink] { + return pulumix.Output[[]*AuditSink]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkArrayOutput) Index(i pulumi.IntInput) AuditSinkOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AuditSink { return vs[0].([]*AuditSink)[vs[1].(int)] @@ -227,6 +258,12 @@ func (o AuditSinkMapOutput) ToAuditSinkMapOutputWithContext(ctx context.Context) return o } +func (o AuditSinkMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AuditSink] { + return pulumix.Output[map[string]*AuditSink]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkMapOutput) MapIndex(k pulumi.StringInput) AuditSinkOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AuditSink { return vs[0].(map[string]*AuditSink)[vs[1].(string)] diff --git a/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkList.go b/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkList.go index bbc8837bf9..cafe28252a 100644 --- a/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkList.go +++ b/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // AuditSinkList is a list of AuditSink items. @@ -114,6 +115,12 @@ func (i *AuditSinkList) ToAuditSinkListOutputWithContext(ctx context.Context) Au return pulumi.ToOutputWithContext(ctx, i).(AuditSinkListOutput) } +func (i *AuditSinkList) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkList] { + return pulumix.Output[*AuditSinkList]{ + OutputState: i.ToAuditSinkListOutputWithContext(ctx).OutputState, + } +} + // AuditSinkListArrayInput is an input type that accepts AuditSinkListArray and AuditSinkListArrayOutput values. // You can construct a concrete instance of `AuditSinkListArrayInput` via: // @@ -139,6 +146,12 @@ func (i AuditSinkListArray) ToAuditSinkListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(AuditSinkListArrayOutput) } +func (i AuditSinkListArray) ToOutput(ctx context.Context) pulumix.Output[[]*AuditSinkList] { + return pulumix.Output[[]*AuditSinkList]{ + OutputState: i.ToAuditSinkListArrayOutputWithContext(ctx).OutputState, + } +} + // AuditSinkListMapInput is an input type that accepts AuditSinkListMap and AuditSinkListMapOutput values. // You can construct a concrete instance of `AuditSinkListMapInput` via: // @@ -164,6 +177,12 @@ func (i AuditSinkListMap) ToAuditSinkListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(AuditSinkListMapOutput) } +func (i AuditSinkListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AuditSinkList] { + return pulumix.Output[map[string]*AuditSinkList]{ + OutputState: i.ToAuditSinkListMapOutputWithContext(ctx).OutputState, + } +} + type AuditSinkListOutput struct{ *pulumi.OutputState } func (AuditSinkListOutput) ElementType() reflect.Type { @@ -178,6 +197,12 @@ func (o AuditSinkListOutput) ToAuditSinkListOutputWithContext(ctx context.Contex return o } +func (o AuditSinkListOutput) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkList] { + return pulumix.Output[*AuditSinkList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o AuditSinkListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *AuditSinkList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o AuditSinkListArrayOutput) ToAuditSinkListArrayOutputWithContext(ctx cont return o } +func (o AuditSinkListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AuditSinkList] { + return pulumix.Output[[]*AuditSinkList]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkListArrayOutput) Index(i pulumi.IntInput) AuditSinkListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AuditSinkList { return vs[0].([]*AuditSinkList)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o AuditSinkListMapOutput) ToAuditSinkListMapOutputWithContext(ctx context. return o } +func (o AuditSinkListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AuditSinkList] { + return pulumix.Output[map[string]*AuditSinkList]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkListMapOutput) MapIndex(k pulumi.StringInput) AuditSinkListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AuditSinkList { return vs[0].(map[string]*AuditSinkList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkPatch.go b/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkPatch.go index 15e2718b96..33bcdc7483 100644 --- a/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkPatch.go +++ b/sdk/go/kubernetes/auditregistration/v1alpha1/auditSinkPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -116,6 +117,12 @@ func (i *AuditSinkPatch) ToAuditSinkPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(AuditSinkPatchOutput) } +func (i *AuditSinkPatch) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkPatch] { + return pulumix.Output[*AuditSinkPatch]{ + OutputState: i.ToAuditSinkPatchOutputWithContext(ctx).OutputState, + } +} + // AuditSinkPatchArrayInput is an input type that accepts AuditSinkPatchArray and AuditSinkPatchArrayOutput values. // You can construct a concrete instance of `AuditSinkPatchArrayInput` via: // @@ -141,6 +148,12 @@ func (i AuditSinkPatchArray) ToAuditSinkPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AuditSinkPatchArrayOutput) } +func (i AuditSinkPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*AuditSinkPatch] { + return pulumix.Output[[]*AuditSinkPatch]{ + OutputState: i.ToAuditSinkPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AuditSinkPatchMapInput is an input type that accepts AuditSinkPatchMap and AuditSinkPatchMapOutput values. // You can construct a concrete instance of `AuditSinkPatchMapInput` via: // @@ -166,6 +179,12 @@ func (i AuditSinkPatchMap) ToAuditSinkPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AuditSinkPatchMapOutput) } +func (i AuditSinkPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AuditSinkPatch] { + return pulumix.Output[map[string]*AuditSinkPatch]{ + OutputState: i.ToAuditSinkPatchMapOutputWithContext(ctx).OutputState, + } +} + type AuditSinkPatchOutput struct{ *pulumi.OutputState } func (AuditSinkPatchOutput) ElementType() reflect.Type { @@ -180,6 +199,12 @@ func (o AuditSinkPatchOutput) ToAuditSinkPatchOutputWithContext(ctx context.Cont return o } +func (o AuditSinkPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkPatch] { + return pulumix.Output[*AuditSinkPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o AuditSinkPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *AuditSinkPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -213,6 +238,12 @@ func (o AuditSinkPatchArrayOutput) ToAuditSinkPatchArrayOutputWithContext(ctx co return o } +func (o AuditSinkPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AuditSinkPatch] { + return pulumix.Output[[]*AuditSinkPatch]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkPatchArrayOutput) Index(i pulumi.IntInput) AuditSinkPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AuditSinkPatch { return vs[0].([]*AuditSinkPatch)[vs[1].(int)] @@ -233,6 +264,12 @@ func (o AuditSinkPatchMapOutput) ToAuditSinkPatchMapOutputWithContext(ctx contex return o } +func (o AuditSinkPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AuditSinkPatch] { + return pulumix.Output[map[string]*AuditSinkPatch]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkPatchMapOutput) MapIndex(k pulumi.StringInput) AuditSinkPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AuditSinkPatch { return vs[0].(map[string]*AuditSinkPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/auditregistration/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/auditregistration/v1alpha1/pulumiTypes.go index 2b0719346a..614a6a77be 100644 --- a/sdk/go/kubernetes/auditregistration/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/auditregistration/v1alpha1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -59,6 +60,12 @@ func (i AuditSinkTypeArgs) ToAuditSinkTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(AuditSinkTypeOutput) } +func (i AuditSinkTypeArgs) ToOutput(ctx context.Context) pulumix.Output[AuditSinkType] { + return pulumix.Output[AuditSinkType]{ + OutputState: i.ToAuditSinkTypeOutputWithContext(ctx).OutputState, + } +} + // AuditSinkTypeArrayInput is an input type that accepts AuditSinkTypeArray and AuditSinkTypeArrayOutput values. // You can construct a concrete instance of `AuditSinkTypeArrayInput` via: // @@ -84,6 +91,12 @@ func (i AuditSinkTypeArray) ToAuditSinkTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(AuditSinkTypeArrayOutput) } +func (i AuditSinkTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]AuditSinkType] { + return pulumix.Output[[]AuditSinkType]{ + OutputState: i.ToAuditSinkTypeArrayOutputWithContext(ctx).OutputState, + } +} + // AuditSink represents a cluster level audit sink type AuditSinkTypeOutput struct{ *pulumi.OutputState } @@ -99,6 +112,12 @@ func (o AuditSinkTypeOutput) ToAuditSinkTypeOutputWithContext(ctx context.Contex return o } +func (o AuditSinkTypeOutput) ToOutput(ctx context.Context) pulumix.Output[AuditSinkType] { + return pulumix.Output[AuditSinkType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o AuditSinkTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v AuditSinkType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -132,6 +151,12 @@ func (o AuditSinkTypeArrayOutput) ToAuditSinkTypeArrayOutputWithContext(ctx cont return o } +func (o AuditSinkTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AuditSinkType] { + return pulumix.Output[[]AuditSinkType]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkTypeArrayOutput) Index(i pulumi.IntInput) AuditSinkTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditSinkType { return vs[0].([]AuditSinkType)[vs[1].(int)] @@ -183,6 +208,12 @@ func (i AuditSinkListTypeArgs) ToAuditSinkListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AuditSinkListTypeOutput) } +func (i AuditSinkListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[AuditSinkListType] { + return pulumix.Output[AuditSinkListType]{ + OutputState: i.ToAuditSinkListTypeOutputWithContext(ctx).OutputState, + } +} + // AuditSinkList is a list of AuditSink items. type AuditSinkListTypeOutput struct{ *pulumi.OutputState } @@ -198,6 +229,12 @@ func (o AuditSinkListTypeOutput) ToAuditSinkListTypeOutputWithContext(ctx contex return o } +func (o AuditSinkListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[AuditSinkListType] { + return pulumix.Output[AuditSinkListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o AuditSinkListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v AuditSinkListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -262,6 +299,12 @@ func (i AuditSinkPatchTypeArgs) ToAuditSinkPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(AuditSinkPatchTypeOutput) } +func (i AuditSinkPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[AuditSinkPatchType] { + return pulumix.Output[AuditSinkPatchType]{ + OutputState: i.ToAuditSinkPatchTypeOutputWithContext(ctx).OutputState, + } +} + // AuditSink represents a cluster level audit sink type AuditSinkPatchTypeOutput struct{ *pulumi.OutputState } @@ -277,6 +320,12 @@ func (o AuditSinkPatchTypeOutput) ToAuditSinkPatchTypeOutputWithContext(ctx cont return o } +func (o AuditSinkPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[AuditSinkPatchType] { + return pulumix.Output[AuditSinkPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o AuditSinkPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v AuditSinkPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -335,6 +384,12 @@ func (i AuditSinkSpecArgs) ToAuditSinkSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(AuditSinkSpecOutput) } +func (i AuditSinkSpecArgs) ToOutput(ctx context.Context) pulumix.Output[AuditSinkSpec] { + return pulumix.Output[AuditSinkSpec]{ + OutputState: i.ToAuditSinkSpecOutputWithContext(ctx).OutputState, + } +} + func (i AuditSinkSpecArgs) ToAuditSinkSpecPtrOutput() AuditSinkSpecPtrOutput { return i.ToAuditSinkSpecPtrOutputWithContext(context.Background()) } @@ -376,6 +431,12 @@ func (i *auditSinkSpecPtrType) ToAuditSinkSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(AuditSinkSpecPtrOutput) } +func (i *auditSinkSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkSpec] { + return pulumix.Output[*AuditSinkSpec]{ + OutputState: i.ToAuditSinkSpecPtrOutputWithContext(ctx).OutputState, + } +} + // AuditSinkSpec holds the spec for the audit sink type AuditSinkSpecOutput struct{ *pulumi.OutputState } @@ -401,6 +462,12 @@ func (o AuditSinkSpecOutput) ToAuditSinkSpecPtrOutputWithContext(ctx context.Con }).(AuditSinkSpecPtrOutput) } +func (o AuditSinkSpecOutput) ToOutput(ctx context.Context) pulumix.Output[AuditSinkSpec] { + return pulumix.Output[AuditSinkSpec]{ + OutputState: o.OutputState, + } +} + // Policy defines the policy for selecting which events should be sent to the webhook required func (o AuditSinkSpecOutput) Policy() PolicyOutput { return o.ApplyT(func(v AuditSinkSpec) Policy { return v.Policy }).(PolicyOutput) @@ -425,6 +492,12 @@ func (o AuditSinkSpecPtrOutput) ToAuditSinkSpecPtrOutputWithContext(ctx context. return o } +func (o AuditSinkSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkSpec] { + return pulumix.Output[*AuditSinkSpec]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkSpecPtrOutput) Elem() AuditSinkSpecOutput { return o.ApplyT(func(v *AuditSinkSpec) AuditSinkSpec { if v != nil { @@ -494,6 +567,12 @@ func (i AuditSinkSpecPatchArgs) ToAuditSinkSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(AuditSinkSpecPatchOutput) } +func (i AuditSinkSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AuditSinkSpecPatch] { + return pulumix.Output[AuditSinkSpecPatch]{ + OutputState: i.ToAuditSinkSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i AuditSinkSpecPatchArgs) ToAuditSinkSpecPatchPtrOutput() AuditSinkSpecPatchPtrOutput { return i.ToAuditSinkSpecPatchPtrOutputWithContext(context.Background()) } @@ -535,6 +614,12 @@ func (i *auditSinkSpecPatchPtrType) ToAuditSinkSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AuditSinkSpecPatchPtrOutput) } +func (i *auditSinkSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkSpecPatch] { + return pulumix.Output[*AuditSinkSpecPatch]{ + OutputState: i.ToAuditSinkSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // AuditSinkSpec holds the spec for the audit sink type AuditSinkSpecPatchOutput struct{ *pulumi.OutputState } @@ -560,6 +645,12 @@ func (o AuditSinkSpecPatchOutput) ToAuditSinkSpecPatchPtrOutputWithContext(ctx c }).(AuditSinkSpecPatchPtrOutput) } +func (o AuditSinkSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AuditSinkSpecPatch] { + return pulumix.Output[AuditSinkSpecPatch]{ + OutputState: o.OutputState, + } +} + // Policy defines the policy for selecting which events should be sent to the webhook required func (o AuditSinkSpecPatchOutput) Policy() PolicyPatchPtrOutput { return o.ApplyT(func(v AuditSinkSpecPatch) *PolicyPatch { return v.Policy }).(PolicyPatchPtrOutput) @@ -584,6 +675,12 @@ func (o AuditSinkSpecPatchPtrOutput) ToAuditSinkSpecPatchPtrOutputWithContext(ct return o } +func (o AuditSinkSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AuditSinkSpecPatch] { + return pulumix.Output[*AuditSinkSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o AuditSinkSpecPatchPtrOutput) Elem() AuditSinkSpecPatchOutput { return o.ApplyT(func(v *AuditSinkSpecPatch) AuditSinkSpecPatch { if v != nil { @@ -653,6 +750,12 @@ func (i PolicyArgs) ToPolicyOutputWithContext(ctx context.Context) PolicyOutput return pulumi.ToOutputWithContext(ctx, i).(PolicyOutput) } +func (i PolicyArgs) ToOutput(ctx context.Context) pulumix.Output[Policy] { + return pulumix.Output[Policy]{ + OutputState: i.ToPolicyOutputWithContext(ctx).OutputState, + } +} + func (i PolicyArgs) ToPolicyPtrOutput() PolicyPtrOutput { return i.ToPolicyPtrOutputWithContext(context.Background()) } @@ -694,6 +797,12 @@ func (i *policyPtrType) ToPolicyPtrOutputWithContext(ctx context.Context) Policy return pulumi.ToOutputWithContext(ctx, i).(PolicyPtrOutput) } +func (i *policyPtrType) ToOutput(ctx context.Context) pulumix.Output[*Policy] { + return pulumix.Output[*Policy]{ + OutputState: i.ToPolicyPtrOutputWithContext(ctx).OutputState, + } +} + // Policy defines the configuration of how audit events are logged type PolicyOutput struct{ *pulumi.OutputState } @@ -719,6 +828,12 @@ func (o PolicyOutput) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPt }).(PolicyPtrOutput) } +func (o PolicyOutput) ToOutput(ctx context.Context) pulumix.Output[Policy] { + return pulumix.Output[Policy]{ + OutputState: o.OutputState, + } +} + // The Level that all requests are recorded at. available options: None, Metadata, Request, RequestResponse required func (o PolicyOutput) Level() pulumi.StringOutput { return o.ApplyT(func(v Policy) string { return v.Level }).(pulumi.StringOutput) @@ -743,6 +858,12 @@ func (o PolicyPtrOutput) ToPolicyPtrOutputWithContext(ctx context.Context) Polic return o } +func (o PolicyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Policy] { + return pulumix.Output[*Policy]{ + OutputState: o.OutputState, + } +} + func (o PolicyPtrOutput) Elem() PolicyOutput { return o.ApplyT(func(v *Policy) Policy { if v != nil { @@ -812,6 +933,12 @@ func (i PolicyPatchArgs) ToPolicyPatchOutputWithContext(ctx context.Context) Pol return pulumi.ToOutputWithContext(ctx, i).(PolicyPatchOutput) } +func (i PolicyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyPatch] { + return pulumix.Output[PolicyPatch]{ + OutputState: i.ToPolicyPatchOutputWithContext(ctx).OutputState, + } +} + func (i PolicyPatchArgs) ToPolicyPatchPtrOutput() PolicyPatchPtrOutput { return i.ToPolicyPatchPtrOutputWithContext(context.Background()) } @@ -853,6 +980,12 @@ func (i *policyPatchPtrType) ToPolicyPatchPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(PolicyPatchPtrOutput) } +func (i *policyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PolicyPatch] { + return pulumix.Output[*PolicyPatch]{ + OutputState: i.ToPolicyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Policy defines the configuration of how audit events are logged type PolicyPatchOutput struct{ *pulumi.OutputState } @@ -878,6 +1011,12 @@ func (o PolicyPatchOutput) ToPolicyPatchPtrOutputWithContext(ctx context.Context }).(PolicyPatchPtrOutput) } +func (o PolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyPatch] { + return pulumix.Output[PolicyPatch]{ + OutputState: o.OutputState, + } +} + // The Level that all requests are recorded at. available options: None, Metadata, Request, RequestResponse required func (o PolicyPatchOutput) Level() pulumi.StringPtrOutput { return o.ApplyT(func(v PolicyPatch) *string { return v.Level }).(pulumi.StringPtrOutput) @@ -902,6 +1041,12 @@ func (o PolicyPatchPtrOutput) ToPolicyPatchPtrOutputWithContext(ctx context.Cont return o } +func (o PolicyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PolicyPatch] { + return pulumix.Output[*PolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyPatchPtrOutput) Elem() PolicyPatchOutput { return o.ApplyT(func(v *PolicyPatch) PolicyPatch { if v != nil { @@ -979,6 +1124,12 @@ func (i ServiceReferenceArgs) ToServiceReferenceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceReferenceOutput) } +func (i ServiceReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: i.ToServiceReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferenceArgs) ToServiceReferencePtrOutput() ServiceReferencePtrOutput { return i.ToServiceReferencePtrOutputWithContext(context.Background()) } @@ -1020,6 +1171,12 @@ func (i *serviceReferencePtrType) ToServiceReferencePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePtrOutput) } +func (i *serviceReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: i.ToServiceReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferenceOutput struct{ *pulumi.OutputState } @@ -1045,6 +1202,12 @@ func (o ServiceReferenceOutput) ToServiceReferencePtrOutputWithContext(ctx conte }).(ServiceReferencePtrOutput) } +func (o ServiceReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReference] { + return pulumix.Output[ServiceReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the service. Required func (o ServiceReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceReference) string { return v.Name }).(pulumi.StringOutput) @@ -1079,6 +1242,12 @@ func (o ServiceReferencePtrOutput) ToServiceReferencePtrOutputWithContext(ctx co return o } +func (o ServiceReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReference] { + return pulumix.Output[*ServiceReference]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePtrOutput) Elem() ServiceReferenceOutput { return o.ApplyT(func(v *ServiceReference) ServiceReference { if v != nil { @@ -1176,6 +1345,12 @@ func (i ServiceReferencePatchArgs) ToServiceReferencePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchOutput) } +func (i ServiceReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceReferencePatchArgs) ToServiceReferencePatchPtrOutput() ServiceReferencePatchPtrOutput { return i.ToServiceReferencePatchPtrOutputWithContext(context.Background()) } @@ -1217,6 +1392,12 @@ func (i *serviceReferencePatchPtrType) ToServiceReferencePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceReferencePatchPtrOutput) } +func (i *serviceReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: i.ToServiceReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceReference holds a reference to Service.legacy.k8s.io type ServiceReferencePatchOutput struct{ *pulumi.OutputState } @@ -1242,6 +1423,12 @@ func (o ServiceReferencePatchOutput) ToServiceReferencePatchPtrOutputWithContext }).(ServiceReferencePatchPtrOutput) } +func (o ServiceReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceReferencePatch] { + return pulumix.Output[ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the service. Required func (o ServiceReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1276,6 +1463,12 @@ func (o ServiceReferencePatchPtrOutput) ToServiceReferencePatchPtrOutputWithCont return o } +func (o ServiceReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceReferencePatch] { + return pulumix.Output[*ServiceReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceReferencePatchPtrOutput) Elem() ServiceReferencePatchOutput { return o.ApplyT(func(v *ServiceReferencePatch) ServiceReferencePatch { if v != nil { @@ -1365,6 +1558,12 @@ func (i WebhookArgs) ToWebhookOutputWithContext(ctx context.Context) WebhookOutp return pulumi.ToOutputWithContext(ctx, i).(WebhookOutput) } +func (i WebhookArgs) ToOutput(ctx context.Context) pulumix.Output[Webhook] { + return pulumix.Output[Webhook]{ + OutputState: i.ToWebhookOutputWithContext(ctx).OutputState, + } +} + func (i WebhookArgs) ToWebhookPtrOutput() WebhookPtrOutput { return i.ToWebhookPtrOutputWithContext(context.Background()) } @@ -1406,6 +1605,12 @@ func (i *webhookPtrType) ToWebhookPtrOutputWithContext(ctx context.Context) Webh return pulumi.ToOutputWithContext(ctx, i).(WebhookPtrOutput) } +func (i *webhookPtrType) ToOutput(ctx context.Context) pulumix.Output[*Webhook] { + return pulumix.Output[*Webhook]{ + OutputState: i.ToWebhookPtrOutputWithContext(ctx).OutputState, + } +} + // Webhook holds the configuration of the webhook type WebhookOutput struct{ *pulumi.OutputState } @@ -1431,6 +1636,12 @@ func (o WebhookOutput) ToWebhookPtrOutputWithContext(ctx context.Context) Webhoo }).(WebhookPtrOutput) } +func (o WebhookOutput) ToOutput(ctx context.Context) pulumix.Output[Webhook] { + return pulumix.Output[Webhook]{ + OutputState: o.OutputState, + } +} + // ClientConfig holds the connection parameters for the webhook required func (o WebhookOutput) ClientConfig() WebhookClientConfigOutput { return o.ApplyT(func(v Webhook) WebhookClientConfig { return v.ClientConfig }).(WebhookClientConfigOutput) @@ -1455,6 +1666,12 @@ func (o WebhookPtrOutput) ToWebhookPtrOutputWithContext(ctx context.Context) Web return o } +func (o WebhookPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Webhook] { + return pulumix.Output[*Webhook]{ + OutputState: o.OutputState, + } +} + func (o WebhookPtrOutput) Elem() WebhookOutput { return o.ApplyT(func(v *Webhook) Webhook { if v != nil { @@ -1552,6 +1769,12 @@ func (i WebhookClientConfigArgs) ToWebhookClientConfigOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigOutput) } +func (i WebhookClientConfigArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigArgs) ToWebhookClientConfigPtrOutput() WebhookClientConfigPtrOutput { return i.ToWebhookClientConfigPtrOutputWithContext(context.Background()) } @@ -1593,6 +1816,12 @@ func (i *webhookClientConfigPtrType) ToWebhookClientConfigPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPtrOutput) } +func (i *webhookClientConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfig] { + return pulumix.Output[*WebhookClientConfig]{ + OutputState: i.ToWebhookClientConfigPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a connection with the webhook type WebhookClientConfigOutput struct{ *pulumi.OutputState } @@ -1618,6 +1847,12 @@ func (o WebhookClientConfigOutput) ToWebhookClientConfigPtrOutputWithContext(ctx }).(WebhookClientConfigPtrOutput) } +func (o WebhookClientConfigOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfig] { + return pulumix.Output[WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + // `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfig) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -1659,6 +1894,12 @@ func (o WebhookClientConfigPtrOutput) ToWebhookClientConfigPtrOutputWithContext( return o } +func (o WebhookClientConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfig] { + return pulumix.Output[*WebhookClientConfig]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPtrOutput) Elem() WebhookClientConfigOutput { return o.ApplyT(func(v *WebhookClientConfig) WebhookClientConfig { if v != nil { @@ -1778,6 +2019,12 @@ func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchOutput) } +func (i WebhookClientConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookClientConfigPatchArgs) ToWebhookClientConfigPatchPtrOutput() WebhookClientConfigPatchPtrOutput { return i.ToWebhookClientConfigPatchPtrOutputWithContext(context.Background()) } @@ -1819,6 +2066,12 @@ func (i *webhookClientConfigPatchPtrType) ToWebhookClientConfigPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(WebhookClientConfigPatchPtrOutput) } +func (i *webhookClientConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: i.ToWebhookClientConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookClientConfig contains the information to make a connection with the webhook type WebhookClientConfigPatchOutput struct{ *pulumi.OutputState } @@ -1844,6 +2097,12 @@ func (o WebhookClientConfigPatchOutput) ToWebhookClientConfigPatchPtrOutputWithC }).(WebhookClientConfigPatchPtrOutput) } +func (o WebhookClientConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookClientConfigPatch] { + return pulumix.Output[WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + // `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. func (o WebhookClientConfigPatchOutput) CaBundle() pulumi.StringPtrOutput { return o.ApplyT(func(v WebhookClientConfigPatch) *string { return v.CaBundle }).(pulumi.StringPtrOutput) @@ -1885,6 +2144,12 @@ func (o WebhookClientConfigPatchPtrOutput) ToWebhookClientConfigPatchPtrOutputWi return o } +func (o WebhookClientConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookClientConfigPatch] { + return pulumix.Output[*WebhookClientConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookClientConfigPatchPtrOutput) Elem() WebhookClientConfigPatchOutput { return o.ApplyT(func(v *WebhookClientConfigPatch) WebhookClientConfigPatch { if v != nil { @@ -1976,6 +2241,12 @@ func (i WebhookPatchArgs) ToWebhookPatchOutputWithContext(ctx context.Context) W return pulumi.ToOutputWithContext(ctx, i).(WebhookPatchOutput) } +func (i WebhookPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookPatch] { + return pulumix.Output[WebhookPatch]{ + OutputState: i.ToWebhookPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookPatchArgs) ToWebhookPatchPtrOutput() WebhookPatchPtrOutput { return i.ToWebhookPatchPtrOutputWithContext(context.Background()) } @@ -2017,6 +2288,12 @@ func (i *webhookPatchPtrType) ToWebhookPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(WebhookPatchPtrOutput) } +func (i *webhookPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookPatch] { + return pulumix.Output[*WebhookPatch]{ + OutputState: i.ToWebhookPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Webhook holds the configuration of the webhook type WebhookPatchOutput struct{ *pulumi.OutputState } @@ -2042,6 +2319,12 @@ func (o WebhookPatchOutput) ToWebhookPatchPtrOutputWithContext(ctx context.Conte }).(WebhookPatchPtrOutput) } +func (o WebhookPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookPatch] { + return pulumix.Output[WebhookPatch]{ + OutputState: o.OutputState, + } +} + // ClientConfig holds the connection parameters for the webhook required func (o WebhookPatchOutput) ClientConfig() WebhookClientConfigPatchPtrOutput { return o.ApplyT(func(v WebhookPatch) *WebhookClientConfigPatch { return v.ClientConfig }).(WebhookClientConfigPatchPtrOutput) @@ -2066,6 +2349,12 @@ func (o WebhookPatchPtrOutput) ToWebhookPatchPtrOutputWithContext(ctx context.Co return o } +func (o WebhookPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookPatch] { + return pulumix.Output[*WebhookPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookPatchPtrOutput) Elem() WebhookPatchOutput { return o.ApplyT(func(v *WebhookPatch) WebhookPatch { if v != nil { @@ -2135,6 +2424,12 @@ func (i WebhookThrottleConfigArgs) ToWebhookThrottleConfigOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(WebhookThrottleConfigOutput) } +func (i WebhookThrottleConfigArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookThrottleConfig] { + return pulumix.Output[WebhookThrottleConfig]{ + OutputState: i.ToWebhookThrottleConfigOutputWithContext(ctx).OutputState, + } +} + func (i WebhookThrottleConfigArgs) ToWebhookThrottleConfigPtrOutput() WebhookThrottleConfigPtrOutput { return i.ToWebhookThrottleConfigPtrOutputWithContext(context.Background()) } @@ -2176,6 +2471,12 @@ func (i *webhookThrottleConfigPtrType) ToWebhookThrottleConfigPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(WebhookThrottleConfigPtrOutput) } +func (i *webhookThrottleConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookThrottleConfig] { + return pulumix.Output[*WebhookThrottleConfig]{ + OutputState: i.ToWebhookThrottleConfigPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookThrottleConfig holds the configuration for throttling events type WebhookThrottleConfigOutput struct{ *pulumi.OutputState } @@ -2201,6 +2502,12 @@ func (o WebhookThrottleConfigOutput) ToWebhookThrottleConfigPtrOutputWithContext }).(WebhookThrottleConfigPtrOutput) } +func (o WebhookThrottleConfigOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookThrottleConfig] { + return pulumix.Output[WebhookThrottleConfig]{ + OutputState: o.OutputState, + } +} + // ThrottleBurst is the maximum number of events sent at the same moment default 15 QPS func (o WebhookThrottleConfigOutput) Burst() pulumi.IntPtrOutput { return o.ApplyT(func(v WebhookThrottleConfig) *int { return v.Burst }).(pulumi.IntPtrOutput) @@ -2225,6 +2532,12 @@ func (o WebhookThrottleConfigPtrOutput) ToWebhookThrottleConfigPtrOutputWithCont return o } +func (o WebhookThrottleConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookThrottleConfig] { + return pulumix.Output[*WebhookThrottleConfig]{ + OutputState: o.OutputState, + } +} + func (o WebhookThrottleConfigPtrOutput) Elem() WebhookThrottleConfigOutput { return o.ApplyT(func(v *WebhookThrottleConfig) WebhookThrottleConfig { if v != nil { @@ -2294,6 +2607,12 @@ func (i WebhookThrottleConfigPatchArgs) ToWebhookThrottleConfigPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(WebhookThrottleConfigPatchOutput) } +func (i WebhookThrottleConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WebhookThrottleConfigPatch] { + return pulumix.Output[WebhookThrottleConfigPatch]{ + OutputState: i.ToWebhookThrottleConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i WebhookThrottleConfigPatchArgs) ToWebhookThrottleConfigPatchPtrOutput() WebhookThrottleConfigPatchPtrOutput { return i.ToWebhookThrottleConfigPatchPtrOutputWithContext(context.Background()) } @@ -2335,6 +2654,12 @@ func (i *webhookThrottleConfigPatchPtrType) ToWebhookThrottleConfigPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(WebhookThrottleConfigPatchPtrOutput) } +func (i *webhookThrottleConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WebhookThrottleConfigPatch] { + return pulumix.Output[*WebhookThrottleConfigPatch]{ + OutputState: i.ToWebhookThrottleConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WebhookThrottleConfig holds the configuration for throttling events type WebhookThrottleConfigPatchOutput struct{ *pulumi.OutputState } @@ -2360,6 +2685,12 @@ func (o WebhookThrottleConfigPatchOutput) ToWebhookThrottleConfigPatchPtrOutputW }).(WebhookThrottleConfigPatchPtrOutput) } +func (o WebhookThrottleConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WebhookThrottleConfigPatch] { + return pulumix.Output[WebhookThrottleConfigPatch]{ + OutputState: o.OutputState, + } +} + // ThrottleBurst is the maximum number of events sent at the same moment default 15 QPS func (o WebhookThrottleConfigPatchOutput) Burst() pulumi.IntPtrOutput { return o.ApplyT(func(v WebhookThrottleConfigPatch) *int { return v.Burst }).(pulumi.IntPtrOutput) @@ -2384,6 +2715,12 @@ func (o WebhookThrottleConfigPatchPtrOutput) ToWebhookThrottleConfigPatchPtrOutp return o } +func (o WebhookThrottleConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WebhookThrottleConfigPatch] { + return pulumix.Output[*WebhookThrottleConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o WebhookThrottleConfigPatchPtrOutput) Elem() WebhookThrottleConfigPatchOutput { return o.ApplyT(func(v *WebhookThrottleConfigPatch) WebhookThrottleConfigPatch { if v != nil { diff --git a/sdk/go/kubernetes/authentication/v1/pulumiTypes.go b/sdk/go/kubernetes/authentication/v1/pulumiTypes.go index 04a27bc2ef..c04b528332 100644 --- a/sdk/go/kubernetes/authentication/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/authentication/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -61,6 +62,12 @@ func (i BoundObjectReferenceArgs) ToBoundObjectReferenceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(BoundObjectReferenceOutput) } +func (i BoundObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[BoundObjectReference] { + return pulumix.Output[BoundObjectReference]{ + OutputState: i.ToBoundObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i BoundObjectReferenceArgs) ToBoundObjectReferencePtrOutput() BoundObjectReferencePtrOutput { return i.ToBoundObjectReferencePtrOutputWithContext(context.Background()) } @@ -102,6 +109,12 @@ func (i *boundObjectReferencePtrType) ToBoundObjectReferencePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(BoundObjectReferencePtrOutput) } +func (i *boundObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*BoundObjectReference] { + return pulumix.Output[*BoundObjectReference]{ + OutputState: i.ToBoundObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // BoundObjectReference is a reference to an object that a token is bound to. type BoundObjectReferenceOutput struct{ *pulumi.OutputState } @@ -127,6 +140,12 @@ func (o BoundObjectReferenceOutput) ToBoundObjectReferencePtrOutputWithContext(c }).(BoundObjectReferencePtrOutput) } +func (o BoundObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[BoundObjectReference] { + return pulumix.Output[BoundObjectReference]{ + OutputState: o.OutputState, + } +} + // API version of the referent. func (o BoundObjectReferenceOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v BoundObjectReference) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -161,6 +180,12 @@ func (o BoundObjectReferencePtrOutput) ToBoundObjectReferencePtrOutputWithContex return o } +func (o BoundObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*BoundObjectReference] { + return pulumix.Output[*BoundObjectReference]{ + OutputState: o.OutputState, + } +} + func (o BoundObjectReferencePtrOutput) Elem() BoundObjectReferenceOutput { return o.ApplyT(func(v *BoundObjectReference) BoundObjectReference { if v != nil { @@ -258,6 +283,12 @@ func (i BoundObjectReferencePatchArgs) ToBoundObjectReferencePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(BoundObjectReferencePatchOutput) } +func (i BoundObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[BoundObjectReferencePatch] { + return pulumix.Output[BoundObjectReferencePatch]{ + OutputState: i.ToBoundObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i BoundObjectReferencePatchArgs) ToBoundObjectReferencePatchPtrOutput() BoundObjectReferencePatchPtrOutput { return i.ToBoundObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -299,6 +330,12 @@ func (i *boundObjectReferencePatchPtrType) ToBoundObjectReferencePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(BoundObjectReferencePatchPtrOutput) } +func (i *boundObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*BoundObjectReferencePatch] { + return pulumix.Output[*BoundObjectReferencePatch]{ + OutputState: i.ToBoundObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // BoundObjectReference is a reference to an object that a token is bound to. type BoundObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -324,6 +361,12 @@ func (o BoundObjectReferencePatchOutput) ToBoundObjectReferencePatchPtrOutputWit }).(BoundObjectReferencePatchPtrOutput) } +func (o BoundObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[BoundObjectReferencePatch] { + return pulumix.Output[BoundObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // API version of the referent. func (o BoundObjectReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v BoundObjectReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -358,6 +401,12 @@ func (o BoundObjectReferencePatchPtrOutput) ToBoundObjectReferencePatchPtrOutput return o } +func (o BoundObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*BoundObjectReferencePatch] { + return pulumix.Output[*BoundObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o BoundObjectReferencePatchPtrOutput) Elem() BoundObjectReferencePatchOutput { return o.ApplyT(func(v *BoundObjectReferencePatch) BoundObjectReferencePatch { if v != nil { @@ -455,6 +504,12 @@ func (i SelfSubjectReviewArgs) ToSelfSubjectReviewOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewOutput) } +func (i SelfSubjectReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReview] { + return pulumix.Output[SelfSubjectReview]{ + OutputState: i.ToSelfSubjectReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReview contains the user information that the kube-apiserver has about the user making this request. When using impersonation, users will receive the user info of the user being impersonated. If impersonation or request header authentication is used, any extra keys will have their case ignored and returned as lowercase. type SelfSubjectReviewOutput struct{ *pulumi.OutputState } @@ -470,6 +525,12 @@ func (o SelfSubjectReviewOutput) ToSelfSubjectReviewOutputWithContext(ctx contex return o } +func (o SelfSubjectReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReview] { + return pulumix.Output[SelfSubjectReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -537,6 +598,12 @@ func (i SelfSubjectReviewPatchArgs) ToSelfSubjectReviewPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewPatchOutput) } +func (i SelfSubjectReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewPatch] { + return pulumix.Output[SelfSubjectReviewPatch]{ + OutputState: i.ToSelfSubjectReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReview contains the user information that the kube-apiserver has about the user making this request. When using impersonation, users will receive the user info of the user being impersonated. If impersonation or request header authentication is used, any extra keys will have their case ignored and returned as lowercase. type SelfSubjectReviewPatchOutput struct{ *pulumi.OutputState } @@ -552,6 +619,12 @@ func (o SelfSubjectReviewPatchOutput) ToSelfSubjectReviewPatchOutputWithContext( return o } +func (o SelfSubjectReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewPatch] { + return pulumix.Output[SelfSubjectReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -607,6 +680,12 @@ func (i SelfSubjectReviewStatusArgs) ToSelfSubjectReviewStatusOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusOutput) } +func (i SelfSubjectReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatus] { + return pulumix.Output[SelfSubjectReviewStatus]{ + OutputState: i.ToSelfSubjectReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectReviewStatusArgs) ToSelfSubjectReviewStatusPtrOutput() SelfSubjectReviewStatusPtrOutput { return i.ToSelfSubjectReviewStatusPtrOutputWithContext(context.Background()) } @@ -648,6 +727,12 @@ func (i *selfSubjectReviewStatusPtrType) ToSelfSubjectReviewStatusPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPtrOutput) } +func (i *selfSubjectReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatus] { + return pulumix.Output[*SelfSubjectReviewStatus]{ + OutputState: i.ToSelfSubjectReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReviewStatus is filled by the kube-apiserver and sent back to a user. type SelfSubjectReviewStatusOutput struct{ *pulumi.OutputState } @@ -673,6 +758,12 @@ func (o SelfSubjectReviewStatusOutput) ToSelfSubjectReviewStatusPtrOutputWithCon }).(SelfSubjectReviewStatusPtrOutput) } +func (o SelfSubjectReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatus] { + return pulumix.Output[SelfSubjectReviewStatus]{ + OutputState: o.OutputState, + } +} + // User attributes of the user making this request. func (o SelfSubjectReviewStatusOutput) UserInfo() UserInfoPtrOutput { return o.ApplyT(func(v SelfSubjectReviewStatus) *UserInfo { return v.UserInfo }).(UserInfoPtrOutput) @@ -692,6 +783,12 @@ func (o SelfSubjectReviewStatusPtrOutput) ToSelfSubjectReviewStatusPtrOutputWith return o } +func (o SelfSubjectReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatus] { + return pulumix.Output[*SelfSubjectReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectReviewStatusPtrOutput) Elem() SelfSubjectReviewStatusOutput { return o.ApplyT(func(v *SelfSubjectReviewStatus) SelfSubjectReviewStatus { if v != nil { @@ -747,6 +844,12 @@ func (i SelfSubjectReviewStatusPatchArgs) ToSelfSubjectReviewStatusPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPatchOutput) } +func (i SelfSubjectReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatusPatch] { + return pulumix.Output[SelfSubjectReviewStatusPatch]{ + OutputState: i.ToSelfSubjectReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectReviewStatusPatchArgs) ToSelfSubjectReviewStatusPatchPtrOutput() SelfSubjectReviewStatusPatchPtrOutput { return i.ToSelfSubjectReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -788,6 +891,12 @@ func (i *selfSubjectReviewStatusPatchPtrType) ToSelfSubjectReviewStatusPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPatchPtrOutput) } +func (i *selfSubjectReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatusPatch] { + return pulumix.Output[*SelfSubjectReviewStatusPatch]{ + OutputState: i.ToSelfSubjectReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReviewStatus is filled by the kube-apiserver and sent back to a user. type SelfSubjectReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -813,6 +922,12 @@ func (o SelfSubjectReviewStatusPatchOutput) ToSelfSubjectReviewStatusPatchPtrOut }).(SelfSubjectReviewStatusPatchPtrOutput) } +func (o SelfSubjectReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatusPatch] { + return pulumix.Output[SelfSubjectReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // User attributes of the user making this request. func (o SelfSubjectReviewStatusPatchOutput) UserInfo() UserInfoPatchPtrOutput { return o.ApplyT(func(v SelfSubjectReviewStatusPatch) *UserInfoPatch { return v.UserInfo }).(UserInfoPatchPtrOutput) @@ -832,6 +947,12 @@ func (o SelfSubjectReviewStatusPatchPtrOutput) ToSelfSubjectReviewStatusPatchPtr return o } +func (o SelfSubjectReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatusPatch] { + return pulumix.Output[*SelfSubjectReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectReviewStatusPatchPtrOutput) Elem() SelfSubjectReviewStatusPatchOutput { return o.ApplyT(func(v *SelfSubjectReviewStatusPatch) SelfSubjectReviewStatusPatch { if v != nil { @@ -903,6 +1024,12 @@ func (i TokenRequestArgs) ToTokenRequestOutputWithContext(ctx context.Context) T return pulumi.ToOutputWithContext(ctx, i).(TokenRequestOutput) } +func (i TokenRequestArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequest] { + return pulumix.Output[TokenRequest]{ + OutputState: i.ToTokenRequestOutputWithContext(ctx).OutputState, + } +} + // TokenRequest requests a token for a given service account. type TokenRequestOutput struct{ *pulumi.OutputState } @@ -918,6 +1045,12 @@ func (o TokenRequestOutput) ToTokenRequestOutputWithContext(ctx context.Context) return o } +func (o TokenRequestOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequest] { + return pulumix.Output[TokenRequest]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o TokenRequestOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenRequest) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -994,6 +1127,12 @@ func (i TokenRequestPatchArgs) ToTokenRequestPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TokenRequestPatchOutput) } +func (i TokenRequestPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestPatch] { + return pulumix.Output[TokenRequestPatch]{ + OutputState: i.ToTokenRequestPatchOutputWithContext(ctx).OutputState, + } +} + // TokenRequest requests a token for a given service account. type TokenRequestPatchOutput struct{ *pulumi.OutputState } @@ -1009,6 +1148,12 @@ func (o TokenRequestPatchOutput) ToTokenRequestPatchOutputWithContext(ctx contex return o } +func (o TokenRequestPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestPatch] { + return pulumix.Output[TokenRequestPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o TokenRequestPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenRequestPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1077,6 +1222,12 @@ func (i TokenRequestSpecArgs) ToTokenRequestSpecOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(TokenRequestSpecOutput) } +func (i TokenRequestSpecArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestSpec] { + return pulumix.Output[TokenRequestSpec]{ + OutputState: i.ToTokenRequestSpecOutputWithContext(ctx).OutputState, + } +} + // TokenRequestSpec contains client provided parameters of a token request. type TokenRequestSpecOutput struct{ *pulumi.OutputState } @@ -1092,6 +1243,12 @@ func (o TokenRequestSpecOutput) ToTokenRequestSpecOutputWithContext(ctx context. return o } +func (o TokenRequestSpecOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestSpec] { + return pulumix.Output[TokenRequestSpec]{ + OutputState: o.OutputState, + } +} + // Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences. func (o TokenRequestSpecOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenRequestSpec) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -1150,6 +1307,12 @@ func (i TokenRequestSpecPatchArgs) ToTokenRequestSpecPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(TokenRequestSpecPatchOutput) } +func (i TokenRequestSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestSpecPatch] { + return pulumix.Output[TokenRequestSpecPatch]{ + OutputState: i.ToTokenRequestSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i TokenRequestSpecPatchArgs) ToTokenRequestSpecPatchPtrOutput() TokenRequestSpecPatchPtrOutput { return i.ToTokenRequestSpecPatchPtrOutputWithContext(context.Background()) } @@ -1191,6 +1354,12 @@ func (i *tokenRequestSpecPatchPtrType) ToTokenRequestSpecPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(TokenRequestSpecPatchPtrOutput) } +func (i *tokenRequestSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenRequestSpecPatch] { + return pulumix.Output[*TokenRequestSpecPatch]{ + OutputState: i.ToTokenRequestSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TokenRequestSpec contains client provided parameters of a token request. type TokenRequestSpecPatchOutput struct{ *pulumi.OutputState } @@ -1216,6 +1385,12 @@ func (o TokenRequestSpecPatchOutput) ToTokenRequestSpecPatchPtrOutputWithContext }).(TokenRequestSpecPatchPtrOutput) } +func (o TokenRequestSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestSpecPatch] { + return pulumix.Output[TokenRequestSpecPatch]{ + OutputState: o.OutputState, + } +} + // Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences. func (o TokenRequestSpecPatchOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenRequestSpecPatch) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -1245,6 +1420,12 @@ func (o TokenRequestSpecPatchPtrOutput) ToTokenRequestSpecPatchPtrOutputWithCont return o } +func (o TokenRequestSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenRequestSpecPatch] { + return pulumix.Output[*TokenRequestSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestSpecPatchPtrOutput) Elem() TokenRequestSpecPatchOutput { return o.ApplyT(func(v *TokenRequestSpecPatch) TokenRequestSpecPatch { if v != nil { @@ -1324,6 +1505,12 @@ func (i TokenRequestStatusArgs) ToTokenRequestStatusOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(TokenRequestStatusOutput) } +func (i TokenRequestStatusArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestStatus] { + return pulumix.Output[TokenRequestStatus]{ + OutputState: i.ToTokenRequestStatusOutputWithContext(ctx).OutputState, + } +} + func (i TokenRequestStatusArgs) ToTokenRequestStatusPtrOutput() TokenRequestStatusPtrOutput { return i.ToTokenRequestStatusPtrOutputWithContext(context.Background()) } @@ -1365,6 +1552,12 @@ func (i *tokenRequestStatusPtrType) ToTokenRequestStatusPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(TokenRequestStatusPtrOutput) } +func (i *tokenRequestStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenRequestStatus] { + return pulumix.Output[*TokenRequestStatus]{ + OutputState: i.ToTokenRequestStatusPtrOutputWithContext(ctx).OutputState, + } +} + // TokenRequestStatus is the result of a token request. type TokenRequestStatusOutput struct{ *pulumi.OutputState } @@ -1390,6 +1583,12 @@ func (o TokenRequestStatusOutput) ToTokenRequestStatusPtrOutputWithContext(ctx c }).(TokenRequestStatusPtrOutput) } +func (o TokenRequestStatusOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestStatus] { + return pulumix.Output[TokenRequestStatus]{ + OutputState: o.OutputState, + } +} + // ExpirationTimestamp is the time of expiration of the returned token. func (o TokenRequestStatusOutput) ExpirationTimestamp() pulumi.StringOutput { return o.ApplyT(func(v TokenRequestStatus) string { return v.ExpirationTimestamp }).(pulumi.StringOutput) @@ -1414,6 +1613,12 @@ func (o TokenRequestStatusPtrOutput) ToTokenRequestStatusPtrOutputWithContext(ct return o } +func (o TokenRequestStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenRequestStatus] { + return pulumix.Output[*TokenRequestStatus]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestStatusPtrOutput) Elem() TokenRequestStatusOutput { return o.ApplyT(func(v *TokenRequestStatus) TokenRequestStatus { if v != nil { @@ -1483,6 +1688,12 @@ func (i TokenRequestStatusPatchArgs) ToTokenRequestStatusPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(TokenRequestStatusPatchOutput) } +func (i TokenRequestStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestStatusPatch] { + return pulumix.Output[TokenRequestStatusPatch]{ + OutputState: i.ToTokenRequestStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i TokenRequestStatusPatchArgs) ToTokenRequestStatusPatchPtrOutput() TokenRequestStatusPatchPtrOutput { return i.ToTokenRequestStatusPatchPtrOutputWithContext(context.Background()) } @@ -1524,6 +1735,12 @@ func (i *tokenRequestStatusPatchPtrType) ToTokenRequestStatusPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(TokenRequestStatusPatchPtrOutput) } +func (i *tokenRequestStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenRequestStatusPatch] { + return pulumix.Output[*TokenRequestStatusPatch]{ + OutputState: i.ToTokenRequestStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TokenRequestStatus is the result of a token request. type TokenRequestStatusPatchOutput struct{ *pulumi.OutputState } @@ -1549,6 +1766,12 @@ func (o TokenRequestStatusPatchOutput) ToTokenRequestStatusPatchPtrOutputWithCon }).(TokenRequestStatusPatchPtrOutput) } +func (o TokenRequestStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestStatusPatch] { + return pulumix.Output[TokenRequestStatusPatch]{ + OutputState: o.OutputState, + } +} + // ExpirationTimestamp is the time of expiration of the returned token. func (o TokenRequestStatusPatchOutput) ExpirationTimestamp() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenRequestStatusPatch) *string { return v.ExpirationTimestamp }).(pulumi.StringPtrOutput) @@ -1573,6 +1796,12 @@ func (o TokenRequestStatusPatchPtrOutput) ToTokenRequestStatusPatchPtrOutputWith return o } +func (o TokenRequestStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenRequestStatusPatch] { + return pulumix.Output[*TokenRequestStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestStatusPatchPtrOutput) Elem() TokenRequestStatusPatchOutput { return o.ApplyT(func(v *TokenRequestStatusPatch) TokenRequestStatusPatch { if v != nil { @@ -1654,6 +1883,12 @@ func (i TokenReviewArgs) ToTokenReviewOutputWithContext(ctx context.Context) Tok return pulumi.ToOutputWithContext(ctx, i).(TokenReviewOutput) } +func (i TokenReviewArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReview] { + return pulumix.Output[TokenReview]{ + OutputState: i.ToTokenReviewOutputWithContext(ctx).OutputState, + } +} + // TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. type TokenReviewOutput struct{ *pulumi.OutputState } @@ -1669,6 +1904,12 @@ func (o TokenReviewOutput) ToTokenReviewOutputWithContext(ctx context.Context) T return o } +func (o TokenReviewOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReview] { + return pulumix.Output[TokenReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o TokenReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1745,6 +1986,12 @@ func (i TokenReviewPatchArgs) ToTokenReviewPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(TokenReviewPatchOutput) } +func (i TokenReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewPatch] { + return pulumix.Output[TokenReviewPatch]{ + OutputState: i.ToTokenReviewPatchOutputWithContext(ctx).OutputState, + } +} + // TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. type TokenReviewPatchOutput struct{ *pulumi.OutputState } @@ -1760,6 +2007,12 @@ func (o TokenReviewPatchOutput) ToTokenReviewPatchOutputWithContext(ctx context. return o } +func (o TokenReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewPatch] { + return pulumix.Output[TokenReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o TokenReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1824,6 +2077,12 @@ func (i TokenReviewSpecArgs) ToTokenReviewSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(TokenReviewSpecOutput) } +func (i TokenReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpec] { + return pulumix.Output[TokenReviewSpec]{ + OutputState: i.ToTokenReviewSpecOutputWithContext(ctx).OutputState, + } +} + // TokenReviewSpec is a description of the token authentication request. type TokenReviewSpecOutput struct{ *pulumi.OutputState } @@ -1839,6 +2098,12 @@ func (o TokenReviewSpecOutput) ToTokenReviewSpecOutputWithContext(ctx context.Co return o } +func (o TokenReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpec] { + return pulumix.Output[TokenReviewSpec]{ + OutputState: o.OutputState, + } +} + // Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. func (o TokenReviewSpecOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewSpec) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -1888,6 +2153,12 @@ func (i TokenReviewSpecPatchArgs) ToTokenReviewSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TokenReviewSpecPatchOutput) } +func (i TokenReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpecPatch] { + return pulumix.Output[TokenReviewSpecPatch]{ + OutputState: i.ToTokenReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i TokenReviewSpecPatchArgs) ToTokenReviewSpecPatchPtrOutput() TokenReviewSpecPatchPtrOutput { return i.ToTokenReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -1929,6 +2200,12 @@ func (i *tokenReviewSpecPatchPtrType) ToTokenReviewSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(TokenReviewSpecPatchPtrOutput) } +func (i *tokenReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewSpecPatch] { + return pulumix.Output[*TokenReviewSpecPatch]{ + OutputState: i.ToTokenReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TokenReviewSpec is a description of the token authentication request. type TokenReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -1954,6 +2231,12 @@ func (o TokenReviewSpecPatchOutput) ToTokenReviewSpecPatchPtrOutputWithContext(c }).(TokenReviewSpecPatchPtrOutput) } +func (o TokenReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpecPatch] { + return pulumix.Output[TokenReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. func (o TokenReviewSpecPatchOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewSpecPatch) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -1978,6 +2261,12 @@ func (o TokenReviewSpecPatchPtrOutput) ToTokenReviewSpecPatchPtrOutputWithContex return o } +func (o TokenReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewSpecPatch] { + return pulumix.Output[*TokenReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenReviewSpecPatchPtrOutput) Elem() TokenReviewSpecPatchOutput { return o.ApplyT(func(v *TokenReviewSpecPatch) TokenReviewSpecPatch { if v != nil { @@ -2055,6 +2344,12 @@ func (i TokenReviewStatusArgs) ToTokenReviewStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusOutput) } +func (i TokenReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatus] { + return pulumix.Output[TokenReviewStatus]{ + OutputState: i.ToTokenReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i TokenReviewStatusArgs) ToTokenReviewStatusPtrOutput() TokenReviewStatusPtrOutput { return i.ToTokenReviewStatusPtrOutputWithContext(context.Background()) } @@ -2096,6 +2391,12 @@ func (i *tokenReviewStatusPtrType) ToTokenReviewStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusPtrOutput) } +func (i *tokenReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatus] { + return pulumix.Output[*TokenReviewStatus]{ + OutputState: i.ToTokenReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // TokenReviewStatus is the result of the token authentication request. type TokenReviewStatusOutput struct{ *pulumi.OutputState } @@ -2121,6 +2422,12 @@ func (o TokenReviewStatusOutput) ToTokenReviewStatusPtrOutputWithContext(ctx con }).(TokenReviewStatusPtrOutput) } +func (o TokenReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatus] { + return pulumix.Output[TokenReviewStatus]{ + OutputState: o.OutputState, + } +} + // Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is "true", the token is valid against the audience of the Kubernetes API server. func (o TokenReviewStatusOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewStatus) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -2155,6 +2462,12 @@ func (o TokenReviewStatusPtrOutput) ToTokenReviewStatusPtrOutputWithContext(ctx return o } +func (o TokenReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatus] { + return pulumix.Output[*TokenReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o TokenReviewStatusPtrOutput) Elem() TokenReviewStatusOutput { return o.ApplyT(func(v *TokenReviewStatus) TokenReviewStatus { if v != nil { @@ -2252,6 +2565,12 @@ func (i TokenReviewStatusPatchArgs) ToTokenReviewStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusPatchOutput) } +func (i TokenReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatusPatch] { + return pulumix.Output[TokenReviewStatusPatch]{ + OutputState: i.ToTokenReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i TokenReviewStatusPatchArgs) ToTokenReviewStatusPatchPtrOutput() TokenReviewStatusPatchPtrOutput { return i.ToTokenReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -2293,6 +2612,12 @@ func (i *tokenReviewStatusPatchPtrType) ToTokenReviewStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusPatchPtrOutput) } +func (i *tokenReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatusPatch] { + return pulumix.Output[*TokenReviewStatusPatch]{ + OutputState: i.ToTokenReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TokenReviewStatus is the result of the token authentication request. type TokenReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -2318,6 +2643,12 @@ func (o TokenReviewStatusPatchOutput) ToTokenReviewStatusPatchPtrOutputWithConte }).(TokenReviewStatusPatchPtrOutput) } +func (o TokenReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatusPatch] { + return pulumix.Output[TokenReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is "true", the token is valid against the audience of the Kubernetes API server. func (o TokenReviewStatusPatchOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewStatusPatch) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -2352,6 +2683,12 @@ func (o TokenReviewStatusPatchPtrOutput) ToTokenReviewStatusPatchPtrOutputWithCo return o } +func (o TokenReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatusPatch] { + return pulumix.Output[*TokenReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenReviewStatusPatchPtrOutput) Elem() TokenReviewStatusPatchOutput { return o.ApplyT(func(v *TokenReviewStatusPatch) TokenReviewStatusPatch { if v != nil { @@ -2449,6 +2786,12 @@ func (i UserInfoArgs) ToUserInfoOutputWithContext(ctx context.Context) UserInfoO return pulumi.ToOutputWithContext(ctx, i).(UserInfoOutput) } +func (i UserInfoArgs) ToOutput(ctx context.Context) pulumix.Output[UserInfo] { + return pulumix.Output[UserInfo]{ + OutputState: i.ToUserInfoOutputWithContext(ctx).OutputState, + } +} + func (i UserInfoArgs) ToUserInfoPtrOutput() UserInfoPtrOutput { return i.ToUserInfoPtrOutputWithContext(context.Background()) } @@ -2490,6 +2833,12 @@ func (i *userInfoPtrType) ToUserInfoPtrOutputWithContext(ctx context.Context) Us return pulumi.ToOutputWithContext(ctx, i).(UserInfoPtrOutput) } +func (i *userInfoPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserInfo] { + return pulumix.Output[*UserInfo]{ + OutputState: i.ToUserInfoPtrOutputWithContext(ctx).OutputState, + } +} + // UserInfo holds the information about the user needed to implement the user.Info interface. type UserInfoOutput struct{ *pulumi.OutputState } @@ -2515,6 +2864,12 @@ func (o UserInfoOutput) ToUserInfoPtrOutputWithContext(ctx context.Context) User }).(UserInfoPtrOutput) } +func (o UserInfoOutput) ToOutput(ctx context.Context) pulumix.Output[UserInfo] { + return pulumix.Output[UserInfo]{ + OutputState: o.OutputState, + } +} + // Any additional information provided by the authenticator. func (o UserInfoOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v UserInfo) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -2549,6 +2904,12 @@ func (o UserInfoPtrOutput) ToUserInfoPtrOutputWithContext(ctx context.Context) U return o } +func (o UserInfoPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserInfo] { + return pulumix.Output[*UserInfo]{ + OutputState: o.OutputState, + } +} + func (o UserInfoPtrOutput) Elem() UserInfoOutput { return o.ApplyT(func(v *UserInfo) UserInfo { if v != nil { @@ -2646,6 +3007,12 @@ func (i UserInfoPatchArgs) ToUserInfoPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(UserInfoPatchOutput) } +func (i UserInfoPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UserInfoPatch] { + return pulumix.Output[UserInfoPatch]{ + OutputState: i.ToUserInfoPatchOutputWithContext(ctx).OutputState, + } +} + func (i UserInfoPatchArgs) ToUserInfoPatchPtrOutput() UserInfoPatchPtrOutput { return i.ToUserInfoPatchPtrOutputWithContext(context.Background()) } @@ -2687,6 +3054,12 @@ func (i *userInfoPatchPtrType) ToUserInfoPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(UserInfoPatchPtrOutput) } +func (i *userInfoPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserInfoPatch] { + return pulumix.Output[*UserInfoPatch]{ + OutputState: i.ToUserInfoPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UserInfo holds the information about the user needed to implement the user.Info interface. type UserInfoPatchOutput struct{ *pulumi.OutputState } @@ -2712,6 +3085,12 @@ func (o UserInfoPatchOutput) ToUserInfoPatchPtrOutputWithContext(ctx context.Con }).(UserInfoPatchPtrOutput) } +func (o UserInfoPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UserInfoPatch] { + return pulumix.Output[UserInfoPatch]{ + OutputState: o.OutputState, + } +} + // Any additional information provided by the authenticator. func (o UserInfoPatchOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v UserInfoPatch) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -2746,6 +3125,12 @@ func (o UserInfoPatchPtrOutput) ToUserInfoPatchPtrOutputWithContext(ctx context. return o } +func (o UserInfoPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserInfoPatch] { + return pulumix.Output[*UserInfoPatch]{ + OutputState: o.OutputState, + } +} + func (o UserInfoPatchPtrOutput) Elem() UserInfoPatchOutput { return o.ApplyT(func(v *UserInfoPatch) UserInfoPatch { if v != nil { diff --git a/sdk/go/kubernetes/authentication/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/authentication/v1alpha1/pulumiTypes.go index 574c249de6..1e19838dff 100644 --- a/sdk/go/kubernetes/authentication/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/authentication/v1alpha1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -62,6 +63,12 @@ func (i SelfSubjectReviewArgs) ToSelfSubjectReviewOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewOutput) } +func (i SelfSubjectReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReview] { + return pulumix.Output[SelfSubjectReview]{ + OutputState: i.ToSelfSubjectReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReview contains the user information that the kube-apiserver has about the user making this request. When using impersonation, users will receive the user info of the user being impersonated. If impersonation or request header authentication is used, any extra keys will have their case ignored and returned as lowercase. type SelfSubjectReviewOutput struct{ *pulumi.OutputState } @@ -77,6 +84,12 @@ func (o SelfSubjectReviewOutput) ToSelfSubjectReviewOutputWithContext(ctx contex return o } +func (o SelfSubjectReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReview] { + return pulumix.Output[SelfSubjectReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -144,6 +157,12 @@ func (i SelfSubjectReviewPatchArgs) ToSelfSubjectReviewPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewPatchOutput) } +func (i SelfSubjectReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewPatch] { + return pulumix.Output[SelfSubjectReviewPatch]{ + OutputState: i.ToSelfSubjectReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReview contains the user information that the kube-apiserver has about the user making this request. When using impersonation, users will receive the user info of the user being impersonated. If impersonation or request header authentication is used, any extra keys will have their case ignored and returned as lowercase. type SelfSubjectReviewPatchOutput struct{ *pulumi.OutputState } @@ -159,6 +178,12 @@ func (o SelfSubjectReviewPatchOutput) ToSelfSubjectReviewPatchOutputWithContext( return o } +func (o SelfSubjectReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewPatch] { + return pulumix.Output[SelfSubjectReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -214,6 +239,12 @@ func (i SelfSubjectReviewStatusArgs) ToSelfSubjectReviewStatusOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusOutput) } +func (i SelfSubjectReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatus] { + return pulumix.Output[SelfSubjectReviewStatus]{ + OutputState: i.ToSelfSubjectReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectReviewStatusArgs) ToSelfSubjectReviewStatusPtrOutput() SelfSubjectReviewStatusPtrOutput { return i.ToSelfSubjectReviewStatusPtrOutputWithContext(context.Background()) } @@ -255,6 +286,12 @@ func (i *selfSubjectReviewStatusPtrType) ToSelfSubjectReviewStatusPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPtrOutput) } +func (i *selfSubjectReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatus] { + return pulumix.Output[*SelfSubjectReviewStatus]{ + OutputState: i.ToSelfSubjectReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReviewStatus is filled by the kube-apiserver and sent back to a user. type SelfSubjectReviewStatusOutput struct{ *pulumi.OutputState } @@ -280,6 +317,12 @@ func (o SelfSubjectReviewStatusOutput) ToSelfSubjectReviewStatusPtrOutputWithCon }).(SelfSubjectReviewStatusPtrOutput) } +func (o SelfSubjectReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatus] { + return pulumix.Output[SelfSubjectReviewStatus]{ + OutputState: o.OutputState, + } +} + // User attributes of the user making this request. func (o SelfSubjectReviewStatusOutput) UserInfo() authenticationv1.UserInfoPtrOutput { return o.ApplyT(func(v SelfSubjectReviewStatus) *authenticationv1.UserInfo { return v.UserInfo }).(authenticationv1.UserInfoPtrOutput) @@ -299,6 +342,12 @@ func (o SelfSubjectReviewStatusPtrOutput) ToSelfSubjectReviewStatusPtrOutputWith return o } +func (o SelfSubjectReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatus] { + return pulumix.Output[*SelfSubjectReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectReviewStatusPtrOutput) Elem() SelfSubjectReviewStatusOutput { return o.ApplyT(func(v *SelfSubjectReviewStatus) SelfSubjectReviewStatus { if v != nil { @@ -354,6 +403,12 @@ func (i SelfSubjectReviewStatusPatchArgs) ToSelfSubjectReviewStatusPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPatchOutput) } +func (i SelfSubjectReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatusPatch] { + return pulumix.Output[SelfSubjectReviewStatusPatch]{ + OutputState: i.ToSelfSubjectReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectReviewStatusPatchArgs) ToSelfSubjectReviewStatusPatchPtrOutput() SelfSubjectReviewStatusPatchPtrOutput { return i.ToSelfSubjectReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -395,6 +450,12 @@ func (i *selfSubjectReviewStatusPatchPtrType) ToSelfSubjectReviewStatusPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPatchPtrOutput) } +func (i *selfSubjectReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatusPatch] { + return pulumix.Output[*SelfSubjectReviewStatusPatch]{ + OutputState: i.ToSelfSubjectReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReviewStatus is filled by the kube-apiserver and sent back to a user. type SelfSubjectReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -420,6 +481,12 @@ func (o SelfSubjectReviewStatusPatchOutput) ToSelfSubjectReviewStatusPatchPtrOut }).(SelfSubjectReviewStatusPatchPtrOutput) } +func (o SelfSubjectReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatusPatch] { + return pulumix.Output[SelfSubjectReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // User attributes of the user making this request. func (o SelfSubjectReviewStatusPatchOutput) UserInfo() authenticationv1.UserInfoPatchPtrOutput { return o.ApplyT(func(v SelfSubjectReviewStatusPatch) *authenticationv1.UserInfoPatch { return v.UserInfo }).(authenticationv1.UserInfoPatchPtrOutput) @@ -439,6 +506,12 @@ func (o SelfSubjectReviewStatusPatchPtrOutput) ToSelfSubjectReviewStatusPatchPtr return o } +func (o SelfSubjectReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatusPatch] { + return pulumix.Output[*SelfSubjectReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectReviewStatusPatchPtrOutput) Elem() SelfSubjectReviewStatusPatchOutput { return o.ApplyT(func(v *SelfSubjectReviewStatusPatch) SelfSubjectReviewStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/authentication/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/authentication/v1beta1/pulumiTypes.go index 2b037a50e3..c80f78ab6f 100644 --- a/sdk/go/kubernetes/authentication/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/authentication/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -62,6 +63,12 @@ func (i SelfSubjectReviewArgs) ToSelfSubjectReviewOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewOutput) } +func (i SelfSubjectReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReview] { + return pulumix.Output[SelfSubjectReview]{ + OutputState: i.ToSelfSubjectReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReview contains the user information that the kube-apiserver has about the user making this request. When using impersonation, users will receive the user info of the user being impersonated. If impersonation or request header authentication is used, any extra keys will have their case ignored and returned as lowercase. type SelfSubjectReviewOutput struct{ *pulumi.OutputState } @@ -77,6 +84,12 @@ func (o SelfSubjectReviewOutput) ToSelfSubjectReviewOutputWithContext(ctx contex return o } +func (o SelfSubjectReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReview] { + return pulumix.Output[SelfSubjectReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -144,6 +157,12 @@ func (i SelfSubjectReviewPatchArgs) ToSelfSubjectReviewPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewPatchOutput) } +func (i SelfSubjectReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewPatch] { + return pulumix.Output[SelfSubjectReviewPatch]{ + OutputState: i.ToSelfSubjectReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReview contains the user information that the kube-apiserver has about the user making this request. When using impersonation, users will receive the user info of the user being impersonated. If impersonation or request header authentication is used, any extra keys will have their case ignored and returned as lowercase. type SelfSubjectReviewPatchOutput struct{ *pulumi.OutputState } @@ -159,6 +178,12 @@ func (o SelfSubjectReviewPatchOutput) ToSelfSubjectReviewPatchOutputWithContext( return o } +func (o SelfSubjectReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewPatch] { + return pulumix.Output[SelfSubjectReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -214,6 +239,12 @@ func (i SelfSubjectReviewStatusArgs) ToSelfSubjectReviewStatusOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusOutput) } +func (i SelfSubjectReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatus] { + return pulumix.Output[SelfSubjectReviewStatus]{ + OutputState: i.ToSelfSubjectReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectReviewStatusArgs) ToSelfSubjectReviewStatusPtrOutput() SelfSubjectReviewStatusPtrOutput { return i.ToSelfSubjectReviewStatusPtrOutputWithContext(context.Background()) } @@ -255,6 +286,12 @@ func (i *selfSubjectReviewStatusPtrType) ToSelfSubjectReviewStatusPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPtrOutput) } +func (i *selfSubjectReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatus] { + return pulumix.Output[*SelfSubjectReviewStatus]{ + OutputState: i.ToSelfSubjectReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReviewStatus is filled by the kube-apiserver and sent back to a user. type SelfSubjectReviewStatusOutput struct{ *pulumi.OutputState } @@ -280,6 +317,12 @@ func (o SelfSubjectReviewStatusOutput) ToSelfSubjectReviewStatusPtrOutputWithCon }).(SelfSubjectReviewStatusPtrOutput) } +func (o SelfSubjectReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatus] { + return pulumix.Output[SelfSubjectReviewStatus]{ + OutputState: o.OutputState, + } +} + // User attributes of the user making this request. func (o SelfSubjectReviewStatusOutput) UserInfo() authenticationv1.UserInfoPtrOutput { return o.ApplyT(func(v SelfSubjectReviewStatus) *authenticationv1.UserInfo { return v.UserInfo }).(authenticationv1.UserInfoPtrOutput) @@ -299,6 +342,12 @@ func (o SelfSubjectReviewStatusPtrOutput) ToSelfSubjectReviewStatusPtrOutputWith return o } +func (o SelfSubjectReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatus] { + return pulumix.Output[*SelfSubjectReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectReviewStatusPtrOutput) Elem() SelfSubjectReviewStatusOutput { return o.ApplyT(func(v *SelfSubjectReviewStatus) SelfSubjectReviewStatus { if v != nil { @@ -354,6 +403,12 @@ func (i SelfSubjectReviewStatusPatchArgs) ToSelfSubjectReviewStatusPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPatchOutput) } +func (i SelfSubjectReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatusPatch] { + return pulumix.Output[SelfSubjectReviewStatusPatch]{ + OutputState: i.ToSelfSubjectReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectReviewStatusPatchArgs) ToSelfSubjectReviewStatusPatchPtrOutput() SelfSubjectReviewStatusPatchPtrOutput { return i.ToSelfSubjectReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -395,6 +450,12 @@ func (i *selfSubjectReviewStatusPatchPtrType) ToSelfSubjectReviewStatusPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectReviewStatusPatchPtrOutput) } +func (i *selfSubjectReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatusPatch] { + return pulumix.Output[*SelfSubjectReviewStatusPatch]{ + OutputState: i.ToSelfSubjectReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectReviewStatus is filled by the kube-apiserver and sent back to a user. type SelfSubjectReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -420,6 +481,12 @@ func (o SelfSubjectReviewStatusPatchOutput) ToSelfSubjectReviewStatusPatchPtrOut }).(SelfSubjectReviewStatusPatchPtrOutput) } +func (o SelfSubjectReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectReviewStatusPatch] { + return pulumix.Output[SelfSubjectReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // User attributes of the user making this request. func (o SelfSubjectReviewStatusPatchOutput) UserInfo() authenticationv1.UserInfoPatchPtrOutput { return o.ApplyT(func(v SelfSubjectReviewStatusPatch) *authenticationv1.UserInfoPatch { return v.UserInfo }).(authenticationv1.UserInfoPatchPtrOutput) @@ -439,6 +506,12 @@ func (o SelfSubjectReviewStatusPatchPtrOutput) ToSelfSubjectReviewStatusPatchPtr return o } +func (o SelfSubjectReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectReviewStatusPatch] { + return pulumix.Output[*SelfSubjectReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectReviewStatusPatchPtrOutput) Elem() SelfSubjectReviewStatusPatchOutput { return o.ApplyT(func(v *SelfSubjectReviewStatusPatch) SelfSubjectReviewStatusPatch { if v != nil { @@ -508,6 +581,12 @@ func (i TokenReviewArgs) ToTokenReviewOutputWithContext(ctx context.Context) Tok return pulumi.ToOutputWithContext(ctx, i).(TokenReviewOutput) } +func (i TokenReviewArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReview] { + return pulumix.Output[TokenReview]{ + OutputState: i.ToTokenReviewOutputWithContext(ctx).OutputState, + } +} + // TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. type TokenReviewOutput struct{ *pulumi.OutputState } @@ -523,6 +602,12 @@ func (o TokenReviewOutput) ToTokenReviewOutputWithContext(ctx context.Context) T return o } +func (o TokenReviewOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReview] { + return pulumix.Output[TokenReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o TokenReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -596,6 +681,12 @@ func (i TokenReviewPatchArgs) ToTokenReviewPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(TokenReviewPatchOutput) } +func (i TokenReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewPatch] { + return pulumix.Output[TokenReviewPatch]{ + OutputState: i.ToTokenReviewPatchOutputWithContext(ctx).OutputState, + } +} + // TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. type TokenReviewPatchOutput struct{ *pulumi.OutputState } @@ -611,6 +702,12 @@ func (o TokenReviewPatchOutput) ToTokenReviewPatchOutputWithContext(ctx context. return o } +func (o TokenReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewPatch] { + return pulumix.Output[TokenReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o TokenReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -674,6 +771,12 @@ func (i TokenReviewSpecArgs) ToTokenReviewSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(TokenReviewSpecOutput) } +func (i TokenReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpec] { + return pulumix.Output[TokenReviewSpec]{ + OutputState: i.ToTokenReviewSpecOutputWithContext(ctx).OutputState, + } +} + // TokenReviewSpec is a description of the token authentication request. type TokenReviewSpecOutput struct{ *pulumi.OutputState } @@ -689,6 +792,12 @@ func (o TokenReviewSpecOutput) ToTokenReviewSpecOutputWithContext(ctx context.Co return o } +func (o TokenReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpec] { + return pulumix.Output[TokenReviewSpec]{ + OutputState: o.OutputState, + } +} + // Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. func (o TokenReviewSpecOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewSpec) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -738,6 +847,12 @@ func (i TokenReviewSpecPatchArgs) ToTokenReviewSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TokenReviewSpecPatchOutput) } +func (i TokenReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpecPatch] { + return pulumix.Output[TokenReviewSpecPatch]{ + OutputState: i.ToTokenReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i TokenReviewSpecPatchArgs) ToTokenReviewSpecPatchPtrOutput() TokenReviewSpecPatchPtrOutput { return i.ToTokenReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -779,6 +894,12 @@ func (i *tokenReviewSpecPatchPtrType) ToTokenReviewSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(TokenReviewSpecPatchPtrOutput) } +func (i *tokenReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewSpecPatch] { + return pulumix.Output[*TokenReviewSpecPatch]{ + OutputState: i.ToTokenReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TokenReviewSpec is a description of the token authentication request. type TokenReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -804,6 +925,12 @@ func (o TokenReviewSpecPatchOutput) ToTokenReviewSpecPatchPtrOutputWithContext(c }).(TokenReviewSpecPatchPtrOutput) } +func (o TokenReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewSpecPatch] { + return pulumix.Output[TokenReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. func (o TokenReviewSpecPatchOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewSpecPatch) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -828,6 +955,12 @@ func (o TokenReviewSpecPatchPtrOutput) ToTokenReviewSpecPatchPtrOutputWithContex return o } +func (o TokenReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewSpecPatch] { + return pulumix.Output[*TokenReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenReviewSpecPatchPtrOutput) Elem() TokenReviewSpecPatchOutput { return o.ApplyT(func(v *TokenReviewSpecPatch) TokenReviewSpecPatch { if v != nil { @@ -905,6 +1038,12 @@ func (i TokenReviewStatusArgs) ToTokenReviewStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusOutput) } +func (i TokenReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatus] { + return pulumix.Output[TokenReviewStatus]{ + OutputState: i.ToTokenReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i TokenReviewStatusArgs) ToTokenReviewStatusPtrOutput() TokenReviewStatusPtrOutput { return i.ToTokenReviewStatusPtrOutputWithContext(context.Background()) } @@ -946,6 +1085,12 @@ func (i *tokenReviewStatusPtrType) ToTokenReviewStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusPtrOutput) } +func (i *tokenReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatus] { + return pulumix.Output[*TokenReviewStatus]{ + OutputState: i.ToTokenReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // TokenReviewStatus is the result of the token authentication request. type TokenReviewStatusOutput struct{ *pulumi.OutputState } @@ -971,6 +1116,12 @@ func (o TokenReviewStatusOutput) ToTokenReviewStatusPtrOutputWithContext(ctx con }).(TokenReviewStatusPtrOutput) } +func (o TokenReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatus] { + return pulumix.Output[TokenReviewStatus]{ + OutputState: o.OutputState, + } +} + // Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is "true", the token is valid against the audience of the Kubernetes API server. func (o TokenReviewStatusOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewStatus) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -1005,6 +1156,12 @@ func (o TokenReviewStatusPtrOutput) ToTokenReviewStatusPtrOutputWithContext(ctx return o } +func (o TokenReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatus] { + return pulumix.Output[*TokenReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o TokenReviewStatusPtrOutput) Elem() TokenReviewStatusOutput { return o.ApplyT(func(v *TokenReviewStatus) TokenReviewStatus { if v != nil { @@ -1102,6 +1259,12 @@ func (i TokenReviewStatusPatchArgs) ToTokenReviewStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusPatchOutput) } +func (i TokenReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatusPatch] { + return pulumix.Output[TokenReviewStatusPatch]{ + OutputState: i.ToTokenReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i TokenReviewStatusPatchArgs) ToTokenReviewStatusPatchPtrOutput() TokenReviewStatusPatchPtrOutput { return i.ToTokenReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -1143,6 +1306,12 @@ func (i *tokenReviewStatusPatchPtrType) ToTokenReviewStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(TokenReviewStatusPatchPtrOutput) } +func (i *tokenReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatusPatch] { + return pulumix.Output[*TokenReviewStatusPatch]{ + OutputState: i.ToTokenReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TokenReviewStatus is the result of the token authentication request. type TokenReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -1168,6 +1337,12 @@ func (o TokenReviewStatusPatchOutput) ToTokenReviewStatusPatchPtrOutputWithConte }).(TokenReviewStatusPatchPtrOutput) } +func (o TokenReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenReviewStatusPatch] { + return pulumix.Output[TokenReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is "true", the token is valid against the audience of the Kubernetes API server. func (o TokenReviewStatusPatchOutput) Audiences() pulumi.StringArrayOutput { return o.ApplyT(func(v TokenReviewStatusPatch) []string { return v.Audiences }).(pulumi.StringArrayOutput) @@ -1202,6 +1377,12 @@ func (o TokenReviewStatusPatchPtrOutput) ToTokenReviewStatusPatchPtrOutputWithCo return o } +func (o TokenReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TokenReviewStatusPatch] { + return pulumix.Output[*TokenReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenReviewStatusPatchPtrOutput) Elem() TokenReviewStatusPatchOutput { return o.ApplyT(func(v *TokenReviewStatusPatch) TokenReviewStatusPatch { if v != nil { @@ -1299,6 +1480,12 @@ func (i UserInfoArgs) ToUserInfoOutputWithContext(ctx context.Context) UserInfoO return pulumi.ToOutputWithContext(ctx, i).(UserInfoOutput) } +func (i UserInfoArgs) ToOutput(ctx context.Context) pulumix.Output[UserInfo] { + return pulumix.Output[UserInfo]{ + OutputState: i.ToUserInfoOutputWithContext(ctx).OutputState, + } +} + func (i UserInfoArgs) ToUserInfoPtrOutput() UserInfoPtrOutput { return i.ToUserInfoPtrOutputWithContext(context.Background()) } @@ -1340,6 +1527,12 @@ func (i *userInfoPtrType) ToUserInfoPtrOutputWithContext(ctx context.Context) Us return pulumi.ToOutputWithContext(ctx, i).(UserInfoPtrOutput) } +func (i *userInfoPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserInfo] { + return pulumix.Output[*UserInfo]{ + OutputState: i.ToUserInfoPtrOutputWithContext(ctx).OutputState, + } +} + // UserInfo holds the information about the user needed to implement the user.Info interface. type UserInfoOutput struct{ *pulumi.OutputState } @@ -1365,6 +1558,12 @@ func (o UserInfoOutput) ToUserInfoPtrOutputWithContext(ctx context.Context) User }).(UserInfoPtrOutput) } +func (o UserInfoOutput) ToOutput(ctx context.Context) pulumix.Output[UserInfo] { + return pulumix.Output[UserInfo]{ + OutputState: o.OutputState, + } +} + // Any additional information provided by the authenticator. func (o UserInfoOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v UserInfo) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -1399,6 +1598,12 @@ func (o UserInfoPtrOutput) ToUserInfoPtrOutputWithContext(ctx context.Context) U return o } +func (o UserInfoPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserInfo] { + return pulumix.Output[*UserInfo]{ + OutputState: o.OutputState, + } +} + func (o UserInfoPtrOutput) Elem() UserInfoOutput { return o.ApplyT(func(v *UserInfo) UserInfo { if v != nil { @@ -1496,6 +1701,12 @@ func (i UserInfoPatchArgs) ToUserInfoPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(UserInfoPatchOutput) } +func (i UserInfoPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UserInfoPatch] { + return pulumix.Output[UserInfoPatch]{ + OutputState: i.ToUserInfoPatchOutputWithContext(ctx).OutputState, + } +} + func (i UserInfoPatchArgs) ToUserInfoPatchPtrOutput() UserInfoPatchPtrOutput { return i.ToUserInfoPatchPtrOutputWithContext(context.Background()) } @@ -1537,6 +1748,12 @@ func (i *userInfoPatchPtrType) ToUserInfoPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(UserInfoPatchPtrOutput) } +func (i *userInfoPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserInfoPatch] { + return pulumix.Output[*UserInfoPatch]{ + OutputState: i.ToUserInfoPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UserInfo holds the information about the user needed to implement the user.Info interface. type UserInfoPatchOutput struct{ *pulumi.OutputState } @@ -1562,6 +1779,12 @@ func (o UserInfoPatchOutput) ToUserInfoPatchPtrOutputWithContext(ctx context.Con }).(UserInfoPatchPtrOutput) } +func (o UserInfoPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UserInfoPatch] { + return pulumix.Output[UserInfoPatch]{ + OutputState: o.OutputState, + } +} + // Any additional information provided by the authenticator. func (o UserInfoPatchOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v UserInfoPatch) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -1596,6 +1819,12 @@ func (o UserInfoPatchPtrOutput) ToUserInfoPatchPtrOutputWithContext(ctx context. return o } +func (o UserInfoPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserInfoPatch] { + return pulumix.Output[*UserInfoPatch]{ + OutputState: o.OutputState, + } +} + func (o UserInfoPatchPtrOutput) Elem() UserInfoPatchOutput { return o.ApplyT(func(v *UserInfoPatch) UserInfoPatch { if v != nil { diff --git a/sdk/go/kubernetes/authorization/v1/pulumiTypes.go b/sdk/go/kubernetes/authorization/v1/pulumiTypes.go index 00a3a415d7..829a41baa0 100644 --- a/sdk/go/kubernetes/authorization/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/authorization/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -65,6 +66,12 @@ func (i LocalSubjectAccessReviewArgs) ToLocalSubjectAccessReviewOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(LocalSubjectAccessReviewOutput) } +func (i LocalSubjectAccessReviewArgs) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReview] { + return pulumix.Output[LocalSubjectAccessReview]{ + OutputState: i.ToLocalSubjectAccessReviewOutputWithContext(ctx).OutputState, + } +} + // LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. type LocalSubjectAccessReviewOutput struct{ *pulumi.OutputState } @@ -80,6 +87,12 @@ func (o LocalSubjectAccessReviewOutput) ToLocalSubjectAccessReviewOutputWithCont return o } +func (o LocalSubjectAccessReviewOutput) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReview] { + return pulumix.Output[LocalSubjectAccessReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LocalSubjectAccessReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalSubjectAccessReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -156,6 +169,12 @@ func (i LocalSubjectAccessReviewPatchArgs) ToLocalSubjectAccessReviewPatchOutput return pulumi.ToOutputWithContext(ctx, i).(LocalSubjectAccessReviewPatchOutput) } +func (i LocalSubjectAccessReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReviewPatch] { + return pulumix.Output[LocalSubjectAccessReviewPatch]{ + OutputState: i.ToLocalSubjectAccessReviewPatchOutputWithContext(ctx).OutputState, + } +} + // LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. type LocalSubjectAccessReviewPatchOutput struct{ *pulumi.OutputState } @@ -171,6 +190,12 @@ func (o LocalSubjectAccessReviewPatchOutput) ToLocalSubjectAccessReviewPatchOutp return o } +func (o LocalSubjectAccessReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReviewPatch] { + return pulumix.Output[LocalSubjectAccessReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LocalSubjectAccessReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalSubjectAccessReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (i NonResourceAttributesArgs) ToNonResourceAttributesOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesOutput) } +func (i NonResourceAttributesArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributes] { + return pulumix.Output[NonResourceAttributes]{ + OutputState: i.ToNonResourceAttributesOutputWithContext(ctx).OutputState, + } +} + func (i NonResourceAttributesArgs) ToNonResourceAttributesPtrOutput() NonResourceAttributesPtrOutput { return i.ToNonResourceAttributesPtrOutputWithContext(context.Background()) } @@ -276,6 +307,12 @@ func (i *nonResourceAttributesPtrType) ToNonResourceAttributesPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesPtrOutput) } +func (i *nonResourceAttributesPtrType) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributes] { + return pulumix.Output[*NonResourceAttributes]{ + OutputState: i.ToNonResourceAttributesPtrOutputWithContext(ctx).OutputState, + } +} + // NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface type NonResourceAttributesOutput struct{ *pulumi.OutputState } @@ -301,6 +338,12 @@ func (o NonResourceAttributesOutput) ToNonResourceAttributesPtrOutputWithContext }).(NonResourceAttributesPtrOutput) } +func (o NonResourceAttributesOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributes] { + return pulumix.Output[NonResourceAttributes]{ + OutputState: o.OutputState, + } +} + // Path is the URL path of the request func (o NonResourceAttributesOutput) Path() pulumi.StringPtrOutput { return o.ApplyT(func(v NonResourceAttributes) *string { return v.Path }).(pulumi.StringPtrOutput) @@ -325,6 +368,12 @@ func (o NonResourceAttributesPtrOutput) ToNonResourceAttributesPtrOutputWithCont return o } +func (o NonResourceAttributesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributes] { + return pulumix.Output[*NonResourceAttributes]{ + OutputState: o.OutputState, + } +} + func (o NonResourceAttributesPtrOutput) Elem() NonResourceAttributesOutput { return o.ApplyT(func(v *NonResourceAttributes) NonResourceAttributes { if v != nil { @@ -394,6 +443,12 @@ func (i NonResourceAttributesPatchArgs) ToNonResourceAttributesPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesPatchOutput) } +func (i NonResourceAttributesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributesPatch] { + return pulumix.Output[NonResourceAttributesPatch]{ + OutputState: i.ToNonResourceAttributesPatchOutputWithContext(ctx).OutputState, + } +} + func (i NonResourceAttributesPatchArgs) ToNonResourceAttributesPatchPtrOutput() NonResourceAttributesPatchPtrOutput { return i.ToNonResourceAttributesPatchPtrOutputWithContext(context.Background()) } @@ -435,6 +490,12 @@ func (i *nonResourceAttributesPatchPtrType) ToNonResourceAttributesPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesPatchPtrOutput) } +func (i *nonResourceAttributesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributesPatch] { + return pulumix.Output[*NonResourceAttributesPatch]{ + OutputState: i.ToNonResourceAttributesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface type NonResourceAttributesPatchOutput struct{ *pulumi.OutputState } @@ -460,6 +521,12 @@ func (o NonResourceAttributesPatchOutput) ToNonResourceAttributesPatchPtrOutputW }).(NonResourceAttributesPatchPtrOutput) } +func (o NonResourceAttributesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributesPatch] { + return pulumix.Output[NonResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + // Path is the URL path of the request func (o NonResourceAttributesPatchOutput) Path() pulumi.StringPtrOutput { return o.ApplyT(func(v NonResourceAttributesPatch) *string { return v.Path }).(pulumi.StringPtrOutput) @@ -484,6 +551,12 @@ func (o NonResourceAttributesPatchPtrOutput) ToNonResourceAttributesPatchPtrOutp return o } +func (o NonResourceAttributesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributesPatch] { + return pulumix.Output[*NonResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourceAttributesPatchPtrOutput) Elem() NonResourceAttributesPatchOutput { return o.ApplyT(func(v *NonResourceAttributesPatch) NonResourceAttributesPatch { if v != nil { @@ -553,6 +626,12 @@ func (i NonResourceRuleArgs) ToNonResourceRuleOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(NonResourceRuleOutput) } +func (i NonResourceRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceRule] { + return pulumix.Output[NonResourceRule]{ + OutputState: i.ToNonResourceRuleOutputWithContext(ctx).OutputState, + } +} + // NonResourceRuleArrayInput is an input type that accepts NonResourceRuleArray and NonResourceRuleArrayOutput values. // You can construct a concrete instance of `NonResourceRuleArrayInput` via: // @@ -578,6 +657,12 @@ func (i NonResourceRuleArray) ToNonResourceRuleArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NonResourceRuleArrayOutput) } +func (i NonResourceRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRule] { + return pulumix.Output[[]NonResourceRule]{ + OutputState: i.ToNonResourceRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourceRule holds information that describes a rule for the non-resource type NonResourceRuleOutput struct{ *pulumi.OutputState } @@ -593,6 +678,12 @@ func (o NonResourceRuleOutput) ToNonResourceRuleOutputWithContext(ctx context.Co return o } +func (o NonResourceRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceRule] { + return pulumix.Output[NonResourceRule]{ + OutputState: o.OutputState, + } +} + // NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. "*" means all. func (o NonResourceRuleOutput) NonResourceURLs() pulumi.StringArrayOutput { return o.ApplyT(func(v NonResourceRule) []string { return v.NonResourceURLs }).(pulumi.StringArrayOutput) @@ -617,6 +708,12 @@ func (o NonResourceRuleArrayOutput) ToNonResourceRuleArrayOutputWithContext(ctx return o } +func (o NonResourceRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRule] { + return pulumix.Output[[]NonResourceRule]{ + OutputState: o.OutputState, + } +} + func (o NonResourceRuleArrayOutput) Index(i pulumi.IntInput) NonResourceRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourceRule { return vs[0].([]NonResourceRule)[vs[1].(int)] @@ -662,6 +759,12 @@ func (i NonResourceRulePatchArgs) ToNonResourceRulePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NonResourceRulePatchOutput) } +func (i NonResourceRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceRulePatch] { + return pulumix.Output[NonResourceRulePatch]{ + OutputState: i.ToNonResourceRulePatchOutputWithContext(ctx).OutputState, + } +} + // NonResourceRulePatchArrayInput is an input type that accepts NonResourceRulePatchArray and NonResourceRulePatchArrayOutput values. // You can construct a concrete instance of `NonResourceRulePatchArrayInput` via: // @@ -687,6 +790,12 @@ func (i NonResourceRulePatchArray) ToNonResourceRulePatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NonResourceRulePatchArrayOutput) } +func (i NonResourceRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRulePatch] { + return pulumix.Output[[]NonResourceRulePatch]{ + OutputState: i.ToNonResourceRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourceRule holds information that describes a rule for the non-resource type NonResourceRulePatchOutput struct{ *pulumi.OutputState } @@ -702,6 +811,12 @@ func (o NonResourceRulePatchOutput) ToNonResourceRulePatchOutputWithContext(ctx return o } +func (o NonResourceRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceRulePatch] { + return pulumix.Output[NonResourceRulePatch]{ + OutputState: o.OutputState, + } +} + // NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. "*" means all. func (o NonResourceRulePatchOutput) NonResourceURLs() pulumi.StringArrayOutput { return o.ApplyT(func(v NonResourceRulePatch) []string { return v.NonResourceURLs }).(pulumi.StringArrayOutput) @@ -726,6 +841,12 @@ func (o NonResourceRulePatchArrayOutput) ToNonResourceRulePatchArrayOutputWithCo return o } +func (o NonResourceRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRulePatch] { + return pulumix.Output[[]NonResourceRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourceRulePatchArrayOutput) Index(i pulumi.IntInput) NonResourceRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourceRulePatch { return vs[0].([]NonResourceRulePatch)[vs[1].(int)] @@ -791,6 +912,12 @@ func (i ResourceAttributesArgs) ToResourceAttributesOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesOutput) } +func (i ResourceAttributesArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributes] { + return pulumix.Output[ResourceAttributes]{ + OutputState: i.ToResourceAttributesOutputWithContext(ctx).OutputState, + } +} + func (i ResourceAttributesArgs) ToResourceAttributesPtrOutput() ResourceAttributesPtrOutput { return i.ToResourceAttributesPtrOutputWithContext(context.Background()) } @@ -832,6 +959,12 @@ func (i *resourceAttributesPtrType) ToResourceAttributesPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesPtrOutput) } +func (i *resourceAttributesPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributes] { + return pulumix.Output[*ResourceAttributes]{ + OutputState: i.ToResourceAttributesPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface type ResourceAttributesOutput struct{ *pulumi.OutputState } @@ -857,6 +990,12 @@ func (o ResourceAttributesOutput) ToResourceAttributesPtrOutputWithContext(ctx c }).(ResourceAttributesPtrOutput) } +func (o ResourceAttributesOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributes] { + return pulumix.Output[ResourceAttributes]{ + OutputState: o.OutputState, + } +} + // Group is the API Group of the Resource. "*" means all. func (o ResourceAttributesOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceAttributes) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -906,6 +1045,12 @@ func (o ResourceAttributesPtrOutput) ToResourceAttributesPtrOutputWithContext(ct return o } +func (o ResourceAttributesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributes] { + return pulumix.Output[*ResourceAttributes]{ + OutputState: o.OutputState, + } +} + func (o ResourceAttributesPtrOutput) Elem() ResourceAttributesOutput { return o.ApplyT(func(v *ResourceAttributes) ResourceAttributes { if v != nil { @@ -1045,6 +1190,12 @@ func (i ResourceAttributesPatchArgs) ToResourceAttributesPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesPatchOutput) } +func (i ResourceAttributesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributesPatch] { + return pulumix.Output[ResourceAttributesPatch]{ + OutputState: i.ToResourceAttributesPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceAttributesPatchArgs) ToResourceAttributesPatchPtrOutput() ResourceAttributesPatchPtrOutput { return i.ToResourceAttributesPatchPtrOutputWithContext(context.Background()) } @@ -1086,6 +1237,12 @@ func (i *resourceAttributesPatchPtrType) ToResourceAttributesPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesPatchPtrOutput) } +func (i *resourceAttributesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributesPatch] { + return pulumix.Output[*ResourceAttributesPatch]{ + OutputState: i.ToResourceAttributesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface type ResourceAttributesPatchOutput struct{ *pulumi.OutputState } @@ -1111,6 +1268,12 @@ func (o ResourceAttributesPatchOutput) ToResourceAttributesPatchPtrOutputWithCon }).(ResourceAttributesPatchPtrOutput) } +func (o ResourceAttributesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributesPatch] { + return pulumix.Output[ResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + // Group is the API Group of the Resource. "*" means all. func (o ResourceAttributesPatchOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceAttributesPatch) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -1160,6 +1323,12 @@ func (o ResourceAttributesPatchPtrOutput) ToResourceAttributesPatchPtrOutputWith return o } +func (o ResourceAttributesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributesPatch] { + return pulumix.Output[*ResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceAttributesPatchPtrOutput) Elem() ResourceAttributesPatchOutput { return o.ApplyT(func(v *ResourceAttributesPatch) ResourceAttributesPatch { if v != nil { @@ -1289,6 +1458,12 @@ func (i ResourceRuleArgs) ToResourceRuleOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(ResourceRuleOutput) } +func (i ResourceRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceRule] { + return pulumix.Output[ResourceRule]{ + OutputState: i.ToResourceRuleOutputWithContext(ctx).OutputState, + } +} + // ResourceRuleArrayInput is an input type that accepts ResourceRuleArray and ResourceRuleArrayOutput values. // You can construct a concrete instance of `ResourceRuleArrayInput` via: // @@ -1314,6 +1489,12 @@ func (i ResourceRuleArray) ToResourceRuleArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ResourceRuleArrayOutput) } +func (i ResourceRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRule] { + return pulumix.Output[[]ResourceRule]{ + OutputState: i.ToResourceRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. type ResourceRuleOutput struct{ *pulumi.OutputState } @@ -1329,6 +1510,12 @@ func (o ResourceRuleOutput) ToResourceRuleOutputWithContext(ctx context.Context) return o } +func (o ResourceRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceRule] { + return pulumix.Output[ResourceRule]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "*" means all. func (o ResourceRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourceRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1365,6 +1552,12 @@ func (o ResourceRuleArrayOutput) ToResourceRuleArrayOutputWithContext(ctx contex return o } +func (o ResourceRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRule] { + return pulumix.Output[[]ResourceRule]{ + OutputState: o.OutputState, + } +} + func (o ResourceRuleArrayOutput) Index(i pulumi.IntInput) ResourceRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceRule { return vs[0].([]ResourceRule)[vs[1].(int)] @@ -1420,6 +1613,12 @@ func (i ResourceRulePatchArgs) ToResourceRulePatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceRulePatchOutput) } +func (i ResourceRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceRulePatch] { + return pulumix.Output[ResourceRulePatch]{ + OutputState: i.ToResourceRulePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceRulePatchArrayInput is an input type that accepts ResourceRulePatchArray and ResourceRulePatchArrayOutput values. // You can construct a concrete instance of `ResourceRulePatchArrayInput` via: // @@ -1445,6 +1644,12 @@ func (i ResourceRulePatchArray) ToResourceRulePatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceRulePatchArrayOutput) } +func (i ResourceRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRulePatch] { + return pulumix.Output[[]ResourceRulePatch]{ + OutputState: i.ToResourceRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. type ResourceRulePatchOutput struct{ *pulumi.OutputState } @@ -1460,6 +1665,12 @@ func (o ResourceRulePatchOutput) ToResourceRulePatchOutputWithContext(ctx contex return o } +func (o ResourceRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceRulePatch] { + return pulumix.Output[ResourceRulePatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "*" means all. func (o ResourceRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourceRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1496,6 +1707,12 @@ func (o ResourceRulePatchArrayOutput) ToResourceRulePatchArrayOutputWithContext( return o } +func (o ResourceRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRulePatch] { + return pulumix.Output[[]ResourceRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceRulePatchArrayOutput) Index(i pulumi.IntInput) ResourceRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceRulePatch { return vs[0].([]ResourceRulePatch)[vs[1].(int)] @@ -1553,6 +1770,12 @@ func (i SelfSubjectAccessReviewArgs) ToSelfSubjectAccessReviewOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewOutput) } +func (i SelfSubjectAccessReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReview] { + return pulumix.Output[SelfSubjectAccessReview]{ + OutputState: i.ToSelfSubjectAccessReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means "in all namespaces". Self is a special case, because users should always be able to check whether they can perform an action type SelfSubjectAccessReviewOutput struct{ *pulumi.OutputState } @@ -1568,6 +1791,12 @@ func (o SelfSubjectAccessReviewOutput) ToSelfSubjectAccessReviewOutputWithContex return o } +func (o SelfSubjectAccessReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReview] { + return pulumix.Output[SelfSubjectAccessReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectAccessReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1644,6 +1873,12 @@ func (i SelfSubjectAccessReviewPatchArgs) ToSelfSubjectAccessReviewPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewPatchOutput) } +func (i SelfSubjectAccessReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewPatch] { + return pulumix.Output[SelfSubjectAccessReviewPatch]{ + OutputState: i.ToSelfSubjectAccessReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means "in all namespaces". Self is a special case, because users should always be able to check whether they can perform an action type SelfSubjectAccessReviewPatchOutput struct{ *pulumi.OutputState } @@ -1659,6 +1894,12 @@ func (o SelfSubjectAccessReviewPatchOutput) ToSelfSubjectAccessReviewPatchOutput return o } +func (o SelfSubjectAccessReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewPatch] { + return pulumix.Output[SelfSubjectAccessReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectAccessReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1723,6 +1964,12 @@ func (i SelfSubjectAccessReviewSpecArgs) ToSelfSubjectAccessReviewSpecOutputWith return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewSpecOutput) } +func (i SelfSubjectAccessReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpec] { + return pulumix.Output[SelfSubjectAccessReviewSpec]{ + OutputState: i.ToSelfSubjectAccessReviewSpecOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SelfSubjectAccessReviewSpecOutput struct{ *pulumi.OutputState } @@ -1738,6 +1985,12 @@ func (o SelfSubjectAccessReviewSpecOutput) ToSelfSubjectAccessReviewSpecOutputWi return o } +func (o SelfSubjectAccessReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpec] { + return pulumix.Output[SelfSubjectAccessReviewSpec]{ + OutputState: o.OutputState, + } +} + // NonResourceAttributes describes information for a non-resource access request func (o SelfSubjectAccessReviewSpecOutput) NonResourceAttributes() NonResourceAttributesPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReviewSpec) *NonResourceAttributes { return v.NonResourceAttributes }).(NonResourceAttributesPtrOutput) @@ -1787,6 +2040,12 @@ func (i SelfSubjectAccessReviewSpecPatchArgs) ToSelfSubjectAccessReviewSpecPatch return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewSpecPatchOutput) } +func (i SelfSubjectAccessReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[SelfSubjectAccessReviewSpecPatch]{ + OutputState: i.ToSelfSubjectAccessReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectAccessReviewSpecPatchArgs) ToSelfSubjectAccessReviewSpecPatchPtrOutput() SelfSubjectAccessReviewSpecPatchPtrOutput { return i.ToSelfSubjectAccessReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -1828,6 +2087,12 @@ func (i *selfSubjectAccessReviewSpecPatchPtrType) ToSelfSubjectAccessReviewSpecP return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewSpecPatchPtrOutput) } +func (i *selfSubjectAccessReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[*SelfSubjectAccessReviewSpecPatch]{ + OutputState: i.ToSelfSubjectAccessReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SelfSubjectAccessReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -1853,6 +2118,12 @@ func (o SelfSubjectAccessReviewSpecPatchOutput) ToSelfSubjectAccessReviewSpecPat }).(SelfSubjectAccessReviewSpecPatchPtrOutput) } +func (o SelfSubjectAccessReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[SelfSubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // NonResourceAttributes describes information for a non-resource access request func (o SelfSubjectAccessReviewSpecPatchOutput) NonResourceAttributes() NonResourceAttributesPatchPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReviewSpecPatch) *NonResourceAttributesPatch { return v.NonResourceAttributes }).(NonResourceAttributesPatchPtrOutput) @@ -1877,6 +2148,12 @@ func (o SelfSubjectAccessReviewSpecPatchPtrOutput) ToSelfSubjectAccessReviewSpec return o } +func (o SelfSubjectAccessReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[*SelfSubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectAccessReviewSpecPatchPtrOutput) Elem() SelfSubjectAccessReviewSpecPatchOutput { return o.ApplyT(func(v *SelfSubjectAccessReviewSpecPatch) SelfSubjectAccessReviewSpecPatch { if v != nil { @@ -1958,6 +2235,12 @@ func (i SelfSubjectRulesReviewArgs) ToSelfSubjectRulesReviewOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewOutput) } +func (i SelfSubjectRulesReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReview] { + return pulumix.Output[SelfSubjectRulesReview]{ + OutputState: i.ToSelfSubjectRulesReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. type SelfSubjectRulesReviewOutput struct{ *pulumi.OutputState } @@ -1973,6 +2256,12 @@ func (o SelfSubjectRulesReviewOutput) ToSelfSubjectRulesReviewOutputWithContext( return o } +func (o SelfSubjectRulesReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReview] { + return pulumix.Output[SelfSubjectRulesReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectRulesReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2049,6 +2338,12 @@ func (i SelfSubjectRulesReviewPatchArgs) ToSelfSubjectRulesReviewPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewPatchOutput) } +func (i SelfSubjectRulesReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewPatch] { + return pulumix.Output[SelfSubjectRulesReviewPatch]{ + OutputState: i.ToSelfSubjectRulesReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. type SelfSubjectRulesReviewPatchOutput struct{ *pulumi.OutputState } @@ -2064,6 +2359,12 @@ func (o SelfSubjectRulesReviewPatchOutput) ToSelfSubjectRulesReviewPatchOutputWi return o } +func (o SelfSubjectRulesReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewPatch] { + return pulumix.Output[SelfSubjectRulesReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectRulesReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2124,6 +2425,12 @@ func (i SelfSubjectRulesReviewSpecArgs) ToSelfSubjectRulesReviewSpecOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewSpecOutput) } +func (i SelfSubjectRulesReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpec] { + return pulumix.Output[SelfSubjectRulesReviewSpec]{ + OutputState: i.ToSelfSubjectRulesReviewSpecOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectRulesReviewSpec defines the specification for SelfSubjectRulesReview. type SelfSubjectRulesReviewSpecOutput struct{ *pulumi.OutputState } @@ -2139,6 +2446,12 @@ func (o SelfSubjectRulesReviewSpecOutput) ToSelfSubjectRulesReviewSpecOutputWith return o } +func (o SelfSubjectRulesReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpec] { + return pulumix.Output[SelfSubjectRulesReviewSpec]{ + OutputState: o.OutputState, + } +} + // Namespace to evaluate rules for. Required. func (o SelfSubjectRulesReviewSpecOutput) Namespace() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReviewSpec) *string { return v.Namespace }).(pulumi.StringPtrOutput) @@ -2179,6 +2492,12 @@ func (i SelfSubjectRulesReviewSpecPatchArgs) ToSelfSubjectRulesReviewSpecPatchOu return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewSpecPatchOutput) } +func (i SelfSubjectRulesReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[SelfSubjectRulesReviewSpecPatch]{ + OutputState: i.ToSelfSubjectRulesReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectRulesReviewSpecPatchArgs) ToSelfSubjectRulesReviewSpecPatchPtrOutput() SelfSubjectRulesReviewSpecPatchPtrOutput { return i.ToSelfSubjectRulesReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -2220,6 +2539,12 @@ func (i *selfSubjectRulesReviewSpecPatchPtrType) ToSelfSubjectRulesReviewSpecPat return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewSpecPatchPtrOutput) } +func (i *selfSubjectRulesReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[*SelfSubjectRulesReviewSpecPatch]{ + OutputState: i.ToSelfSubjectRulesReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectRulesReviewSpec defines the specification for SelfSubjectRulesReview. type SelfSubjectRulesReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -2245,6 +2570,12 @@ func (o SelfSubjectRulesReviewSpecPatchOutput) ToSelfSubjectRulesReviewSpecPatch }).(SelfSubjectRulesReviewSpecPatchPtrOutput) } +func (o SelfSubjectRulesReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[SelfSubjectRulesReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // Namespace to evaluate rules for. Required. func (o SelfSubjectRulesReviewSpecPatchOutput) Namespace() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReviewSpecPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) @@ -2264,6 +2595,12 @@ func (o SelfSubjectRulesReviewSpecPatchPtrOutput) ToSelfSubjectRulesReviewSpecPa return o } +func (o SelfSubjectRulesReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[*SelfSubjectRulesReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectRulesReviewSpecPatchPtrOutput) Elem() SelfSubjectRulesReviewSpecPatchOutput { return o.ApplyT(func(v *SelfSubjectRulesReviewSpecPatch) SelfSubjectRulesReviewSpecPatch { if v != nil { @@ -2335,6 +2672,12 @@ func (i SubjectAccessReviewArgs) ToSubjectAccessReviewOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewOutput) } +func (i SubjectAccessReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReview] { + return pulumix.Output[SubjectAccessReview]{ + OutputState: i.ToSubjectAccessReviewOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReview checks whether or not a user or group can perform an action. type SubjectAccessReviewOutput struct{ *pulumi.OutputState } @@ -2350,6 +2693,12 @@ func (o SubjectAccessReviewOutput) ToSubjectAccessReviewOutputWithContext(ctx co return o } +func (o SubjectAccessReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReview] { + return pulumix.Output[SubjectAccessReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SubjectAccessReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectAccessReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2426,6 +2775,12 @@ func (i SubjectAccessReviewPatchArgs) ToSubjectAccessReviewPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewPatchOutput) } +func (i SubjectAccessReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewPatch] { + return pulumix.Output[SubjectAccessReviewPatch]{ + OutputState: i.ToSubjectAccessReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReview checks whether or not a user or group can perform an action. type SubjectAccessReviewPatchOutput struct{ *pulumi.OutputState } @@ -2441,6 +2796,12 @@ func (o SubjectAccessReviewPatchOutput) ToSubjectAccessReviewPatchOutputWithCont return o } +func (o SubjectAccessReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewPatch] { + return pulumix.Output[SubjectAccessReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SubjectAccessReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectAccessReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2521,6 +2882,12 @@ func (i SubjectAccessReviewSpecArgs) ToSubjectAccessReviewSpecOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewSpecOutput) } +func (i SubjectAccessReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpec] { + return pulumix.Output[SubjectAccessReviewSpec]{ + OutputState: i.ToSubjectAccessReviewSpecOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SubjectAccessReviewSpecOutput struct{ *pulumi.OutputState } @@ -2536,6 +2903,12 @@ func (o SubjectAccessReviewSpecOutput) ToSubjectAccessReviewSpecOutputWithContex return o } +func (o SubjectAccessReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpec] { + return pulumix.Output[SubjectAccessReviewSpec]{ + OutputState: o.OutputState, + } +} + // Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. func (o SubjectAccessReviewSpecOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v SubjectAccessReviewSpec) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -2621,6 +2994,12 @@ func (i SubjectAccessReviewSpecPatchArgs) ToSubjectAccessReviewSpecPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewSpecPatchOutput) } +func (i SubjectAccessReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpecPatch] { + return pulumix.Output[SubjectAccessReviewSpecPatch]{ + OutputState: i.ToSubjectAccessReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i SubjectAccessReviewSpecPatchArgs) ToSubjectAccessReviewSpecPatchPtrOutput() SubjectAccessReviewSpecPatchPtrOutput { return i.ToSubjectAccessReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -2662,6 +3041,12 @@ func (i *subjectAccessReviewSpecPatchPtrType) ToSubjectAccessReviewSpecPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewSpecPatchPtrOutput) } +func (i *subjectAccessReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewSpecPatch] { + return pulumix.Output[*SubjectAccessReviewSpecPatch]{ + OutputState: i.ToSubjectAccessReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SubjectAccessReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -2687,6 +3072,12 @@ func (o SubjectAccessReviewSpecPatchOutput) ToSubjectAccessReviewSpecPatchPtrOut }).(SubjectAccessReviewSpecPatchPtrOutput) } +func (o SubjectAccessReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpecPatch] { + return pulumix.Output[SubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. func (o SubjectAccessReviewSpecPatchOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v SubjectAccessReviewSpecPatch) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -2731,6 +3122,12 @@ func (o SubjectAccessReviewSpecPatchPtrOutput) ToSubjectAccessReviewSpecPatchPtr return o } +func (o SubjectAccessReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewSpecPatch] { + return pulumix.Output[*SubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectAccessReviewSpecPatchPtrOutput) Elem() SubjectAccessReviewSpecPatchOutput { return o.ApplyT(func(v *SubjectAccessReviewSpecPatch) SubjectAccessReviewSpecPatch { if v != nil { @@ -2848,6 +3245,12 @@ func (i SubjectAccessReviewStatusArgs) ToSubjectAccessReviewStatusOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusOutput) } +func (i SubjectAccessReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatus] { + return pulumix.Output[SubjectAccessReviewStatus]{ + OutputState: i.ToSubjectAccessReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SubjectAccessReviewStatusArgs) ToSubjectAccessReviewStatusPtrOutput() SubjectAccessReviewStatusPtrOutput { return i.ToSubjectAccessReviewStatusPtrOutputWithContext(context.Background()) } @@ -2889,6 +3292,12 @@ func (i *subjectAccessReviewStatusPtrType) ToSubjectAccessReviewStatusPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusPtrOutput) } +func (i *subjectAccessReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatus] { + return pulumix.Output[*SubjectAccessReviewStatus]{ + OutputState: i.ToSubjectAccessReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewStatus type SubjectAccessReviewStatusOutput struct{ *pulumi.OutputState } @@ -2914,6 +3323,12 @@ func (o SubjectAccessReviewStatusOutput) ToSubjectAccessReviewStatusPtrOutputWit }).(SubjectAccessReviewStatusPtrOutput) } +func (o SubjectAccessReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatus] { + return pulumix.Output[SubjectAccessReviewStatus]{ + OutputState: o.OutputState, + } +} + // Allowed is required. True if the action would be allowed, false otherwise. func (o SubjectAccessReviewStatusOutput) Allowed() pulumi.BoolOutput { return o.ApplyT(func(v SubjectAccessReviewStatus) bool { return v.Allowed }).(pulumi.BoolOutput) @@ -2948,6 +3363,12 @@ func (o SubjectAccessReviewStatusPtrOutput) ToSubjectAccessReviewStatusPtrOutput return o } +func (o SubjectAccessReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatus] { + return pulumix.Output[*SubjectAccessReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SubjectAccessReviewStatusPtrOutput) Elem() SubjectAccessReviewStatusOutput { return o.ApplyT(func(v *SubjectAccessReviewStatus) SubjectAccessReviewStatus { if v != nil { @@ -3045,6 +3466,12 @@ func (i SubjectAccessReviewStatusPatchArgs) ToSubjectAccessReviewStatusPatchOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusPatchOutput) } +func (i SubjectAccessReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatusPatch] { + return pulumix.Output[SubjectAccessReviewStatusPatch]{ + OutputState: i.ToSubjectAccessReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SubjectAccessReviewStatusPatchArgs) ToSubjectAccessReviewStatusPatchPtrOutput() SubjectAccessReviewStatusPatchPtrOutput { return i.ToSubjectAccessReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -3086,6 +3513,12 @@ func (i *subjectAccessReviewStatusPatchPtrType) ToSubjectAccessReviewStatusPatch return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusPatchPtrOutput) } +func (i *subjectAccessReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatusPatch] { + return pulumix.Output[*SubjectAccessReviewStatusPatch]{ + OutputState: i.ToSubjectAccessReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewStatus type SubjectAccessReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -3111,6 +3544,12 @@ func (o SubjectAccessReviewStatusPatchOutput) ToSubjectAccessReviewStatusPatchPt }).(SubjectAccessReviewStatusPatchPtrOutput) } +func (o SubjectAccessReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatusPatch] { + return pulumix.Output[SubjectAccessReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // Allowed is required. True if the action would be allowed, false otherwise. func (o SubjectAccessReviewStatusPatchOutput) Allowed() pulumi.BoolPtrOutput { return o.ApplyT(func(v SubjectAccessReviewStatusPatch) *bool { return v.Allowed }).(pulumi.BoolPtrOutput) @@ -3145,6 +3584,12 @@ func (o SubjectAccessReviewStatusPatchPtrOutput) ToSubjectAccessReviewStatusPatc return o } +func (o SubjectAccessReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatusPatch] { + return pulumix.Output[*SubjectAccessReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectAccessReviewStatusPatchPtrOutput) Elem() SubjectAccessReviewStatusPatchOutput { return o.ApplyT(func(v *SubjectAccessReviewStatusPatch) SubjectAccessReviewStatusPatch { if v != nil { @@ -3242,6 +3687,12 @@ func (i SubjectRulesReviewStatusArgs) ToSubjectRulesReviewStatusOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusOutput) } +func (i SubjectRulesReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatus] { + return pulumix.Output[SubjectRulesReviewStatus]{ + OutputState: i.ToSubjectRulesReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SubjectRulesReviewStatusArgs) ToSubjectRulesReviewStatusPtrOutput() SubjectRulesReviewStatusPtrOutput { return i.ToSubjectRulesReviewStatusPtrOutputWithContext(context.Background()) } @@ -3283,6 +3734,12 @@ func (i *subjectRulesReviewStatusPtrType) ToSubjectRulesReviewStatusPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusPtrOutput) } +func (i *subjectRulesReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatus] { + return pulumix.Output[*SubjectRulesReviewStatus]{ + OutputState: i.ToSubjectRulesReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. type SubjectRulesReviewStatusOutput struct{ *pulumi.OutputState } @@ -3308,6 +3765,12 @@ func (o SubjectRulesReviewStatusOutput) ToSubjectRulesReviewStatusPtrOutputWithC }).(SubjectRulesReviewStatusPtrOutput) } +func (o SubjectRulesReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatus] { + return pulumix.Output[SubjectRulesReviewStatus]{ + OutputState: o.OutputState, + } +} + // EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. func (o SubjectRulesReviewStatusOutput) EvaluationError() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectRulesReviewStatus) *string { return v.EvaluationError }).(pulumi.StringPtrOutput) @@ -3342,6 +3805,12 @@ func (o SubjectRulesReviewStatusPtrOutput) ToSubjectRulesReviewStatusPtrOutputWi return o } +func (o SubjectRulesReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatus] { + return pulumix.Output[*SubjectRulesReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SubjectRulesReviewStatusPtrOutput) Elem() SubjectRulesReviewStatusOutput { return o.ApplyT(func(v *SubjectRulesReviewStatus) SubjectRulesReviewStatus { if v != nil { @@ -3439,6 +3908,12 @@ func (i SubjectRulesReviewStatusPatchArgs) ToSubjectRulesReviewStatusPatchOutput return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusPatchOutput) } +func (i SubjectRulesReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatusPatch] { + return pulumix.Output[SubjectRulesReviewStatusPatch]{ + OutputState: i.ToSubjectRulesReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SubjectRulesReviewStatusPatchArgs) ToSubjectRulesReviewStatusPatchPtrOutput() SubjectRulesReviewStatusPatchPtrOutput { return i.ToSubjectRulesReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -3480,6 +3955,12 @@ func (i *subjectRulesReviewStatusPatchPtrType) ToSubjectRulesReviewStatusPatchPt return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusPatchPtrOutput) } +func (i *subjectRulesReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatusPatch] { + return pulumix.Output[*SubjectRulesReviewStatusPatch]{ + OutputState: i.ToSubjectRulesReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. type SubjectRulesReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -3505,6 +3986,12 @@ func (o SubjectRulesReviewStatusPatchOutput) ToSubjectRulesReviewStatusPatchPtrO }).(SubjectRulesReviewStatusPatchPtrOutput) } +func (o SubjectRulesReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatusPatch] { + return pulumix.Output[SubjectRulesReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. func (o SubjectRulesReviewStatusPatchOutput) EvaluationError() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectRulesReviewStatusPatch) *string { return v.EvaluationError }).(pulumi.StringPtrOutput) @@ -3539,6 +4026,12 @@ func (o SubjectRulesReviewStatusPatchPtrOutput) ToSubjectRulesReviewStatusPatchP return o } +func (o SubjectRulesReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatusPatch] { + return pulumix.Output[*SubjectRulesReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectRulesReviewStatusPatchPtrOutput) Elem() SubjectRulesReviewStatusPatchOutput { return o.ApplyT(func(v *SubjectRulesReviewStatusPatch) SubjectRulesReviewStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/authorization/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/authorization/v1beta1/pulumiTypes.go index aeac8fb34c..e50cec9af3 100644 --- a/sdk/go/kubernetes/authorization/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/authorization/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -63,6 +64,12 @@ func (i LocalSubjectAccessReviewArgs) ToLocalSubjectAccessReviewOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(LocalSubjectAccessReviewOutput) } +func (i LocalSubjectAccessReviewArgs) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReview] { + return pulumix.Output[LocalSubjectAccessReview]{ + OutputState: i.ToLocalSubjectAccessReviewOutputWithContext(ctx).OutputState, + } +} + // LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. type LocalSubjectAccessReviewOutput struct{ *pulumi.OutputState } @@ -78,6 +85,12 @@ func (o LocalSubjectAccessReviewOutput) ToLocalSubjectAccessReviewOutputWithCont return o } +func (o LocalSubjectAccessReviewOutput) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReview] { + return pulumix.Output[LocalSubjectAccessReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LocalSubjectAccessReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalSubjectAccessReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -151,6 +164,12 @@ func (i LocalSubjectAccessReviewPatchArgs) ToLocalSubjectAccessReviewPatchOutput return pulumi.ToOutputWithContext(ctx, i).(LocalSubjectAccessReviewPatchOutput) } +func (i LocalSubjectAccessReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReviewPatch] { + return pulumix.Output[LocalSubjectAccessReviewPatch]{ + OutputState: i.ToLocalSubjectAccessReviewPatchOutputWithContext(ctx).OutputState, + } +} + // LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. type LocalSubjectAccessReviewPatchOutput struct{ *pulumi.OutputState } @@ -166,6 +185,12 @@ func (o LocalSubjectAccessReviewPatchOutput) ToLocalSubjectAccessReviewPatchOutp return o } +func (o LocalSubjectAccessReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LocalSubjectAccessReviewPatch] { + return pulumix.Output[LocalSubjectAccessReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LocalSubjectAccessReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalSubjectAccessReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -229,6 +254,12 @@ func (i NonResourceAttributesArgs) ToNonResourceAttributesOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesOutput) } +func (i NonResourceAttributesArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributes] { + return pulumix.Output[NonResourceAttributes]{ + OutputState: i.ToNonResourceAttributesOutputWithContext(ctx).OutputState, + } +} + func (i NonResourceAttributesArgs) ToNonResourceAttributesPtrOutput() NonResourceAttributesPtrOutput { return i.ToNonResourceAttributesPtrOutputWithContext(context.Background()) } @@ -270,6 +301,12 @@ func (i *nonResourceAttributesPtrType) ToNonResourceAttributesPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesPtrOutput) } +func (i *nonResourceAttributesPtrType) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributes] { + return pulumix.Output[*NonResourceAttributes]{ + OutputState: i.ToNonResourceAttributesPtrOutputWithContext(ctx).OutputState, + } +} + // NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface type NonResourceAttributesOutput struct{ *pulumi.OutputState } @@ -295,6 +332,12 @@ func (o NonResourceAttributesOutput) ToNonResourceAttributesPtrOutputWithContext }).(NonResourceAttributesPtrOutput) } +func (o NonResourceAttributesOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributes] { + return pulumix.Output[NonResourceAttributes]{ + OutputState: o.OutputState, + } +} + // Path is the URL path of the request func (o NonResourceAttributesOutput) Path() pulumi.StringPtrOutput { return o.ApplyT(func(v NonResourceAttributes) *string { return v.Path }).(pulumi.StringPtrOutput) @@ -319,6 +362,12 @@ func (o NonResourceAttributesPtrOutput) ToNonResourceAttributesPtrOutputWithCont return o } +func (o NonResourceAttributesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributes] { + return pulumix.Output[*NonResourceAttributes]{ + OutputState: o.OutputState, + } +} + func (o NonResourceAttributesPtrOutput) Elem() NonResourceAttributesOutput { return o.ApplyT(func(v *NonResourceAttributes) NonResourceAttributes { if v != nil { @@ -388,6 +437,12 @@ func (i NonResourceAttributesPatchArgs) ToNonResourceAttributesPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesPatchOutput) } +func (i NonResourceAttributesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributesPatch] { + return pulumix.Output[NonResourceAttributesPatch]{ + OutputState: i.ToNonResourceAttributesPatchOutputWithContext(ctx).OutputState, + } +} + func (i NonResourceAttributesPatchArgs) ToNonResourceAttributesPatchPtrOutput() NonResourceAttributesPatchPtrOutput { return i.ToNonResourceAttributesPatchPtrOutputWithContext(context.Background()) } @@ -429,6 +484,12 @@ func (i *nonResourceAttributesPatchPtrType) ToNonResourceAttributesPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(NonResourceAttributesPatchPtrOutput) } +func (i *nonResourceAttributesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributesPatch] { + return pulumix.Output[*NonResourceAttributesPatch]{ + OutputState: i.ToNonResourceAttributesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface type NonResourceAttributesPatchOutput struct{ *pulumi.OutputState } @@ -454,6 +515,12 @@ func (o NonResourceAttributesPatchOutput) ToNonResourceAttributesPatchPtrOutputW }).(NonResourceAttributesPatchPtrOutput) } +func (o NonResourceAttributesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceAttributesPatch] { + return pulumix.Output[NonResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + // Path is the URL path of the request func (o NonResourceAttributesPatchOutput) Path() pulumi.StringPtrOutput { return o.ApplyT(func(v NonResourceAttributesPatch) *string { return v.Path }).(pulumi.StringPtrOutput) @@ -478,6 +545,12 @@ func (o NonResourceAttributesPatchPtrOutput) ToNonResourceAttributesPatchPtrOutp return o } +func (o NonResourceAttributesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NonResourceAttributesPatch] { + return pulumix.Output[*NonResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourceAttributesPatchPtrOutput) Elem() NonResourceAttributesPatchOutput { return o.ApplyT(func(v *NonResourceAttributesPatch) NonResourceAttributesPatch { if v != nil { @@ -547,6 +620,12 @@ func (i NonResourceRuleArgs) ToNonResourceRuleOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(NonResourceRuleOutput) } +func (i NonResourceRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceRule] { + return pulumix.Output[NonResourceRule]{ + OutputState: i.ToNonResourceRuleOutputWithContext(ctx).OutputState, + } +} + // NonResourceRuleArrayInput is an input type that accepts NonResourceRuleArray and NonResourceRuleArrayOutput values. // You can construct a concrete instance of `NonResourceRuleArrayInput` via: // @@ -572,6 +651,12 @@ func (i NonResourceRuleArray) ToNonResourceRuleArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NonResourceRuleArrayOutput) } +func (i NonResourceRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRule] { + return pulumix.Output[[]NonResourceRule]{ + OutputState: i.ToNonResourceRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourceRule holds information that describes a rule for the non-resource type NonResourceRuleOutput struct{ *pulumi.OutputState } @@ -587,6 +672,12 @@ func (o NonResourceRuleOutput) ToNonResourceRuleOutputWithContext(ctx context.Co return o } +func (o NonResourceRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceRule] { + return pulumix.Output[NonResourceRule]{ + OutputState: o.OutputState, + } +} + // NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. "*" means all. func (o NonResourceRuleOutput) NonResourceURLs() pulumi.StringArrayOutput { return o.ApplyT(func(v NonResourceRule) []string { return v.NonResourceURLs }).(pulumi.StringArrayOutput) @@ -611,6 +702,12 @@ func (o NonResourceRuleArrayOutput) ToNonResourceRuleArrayOutputWithContext(ctx return o } +func (o NonResourceRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRule] { + return pulumix.Output[[]NonResourceRule]{ + OutputState: o.OutputState, + } +} + func (o NonResourceRuleArrayOutput) Index(i pulumi.IntInput) NonResourceRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourceRule { return vs[0].([]NonResourceRule)[vs[1].(int)] @@ -656,6 +753,12 @@ func (i NonResourceRulePatchArgs) ToNonResourceRulePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NonResourceRulePatchOutput) } +func (i NonResourceRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourceRulePatch] { + return pulumix.Output[NonResourceRulePatch]{ + OutputState: i.ToNonResourceRulePatchOutputWithContext(ctx).OutputState, + } +} + // NonResourceRulePatchArrayInput is an input type that accepts NonResourceRulePatchArray and NonResourceRulePatchArrayOutput values. // You can construct a concrete instance of `NonResourceRulePatchArrayInput` via: // @@ -681,6 +784,12 @@ func (i NonResourceRulePatchArray) ToNonResourceRulePatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NonResourceRulePatchArrayOutput) } +func (i NonResourceRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRulePatch] { + return pulumix.Output[[]NonResourceRulePatch]{ + OutputState: i.ToNonResourceRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourceRule holds information that describes a rule for the non-resource type NonResourceRulePatchOutput struct{ *pulumi.OutputState } @@ -696,6 +805,12 @@ func (o NonResourceRulePatchOutput) ToNonResourceRulePatchOutputWithContext(ctx return o } +func (o NonResourceRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourceRulePatch] { + return pulumix.Output[NonResourceRulePatch]{ + OutputState: o.OutputState, + } +} + // NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. "*" means all. func (o NonResourceRulePatchOutput) NonResourceURLs() pulumi.StringArrayOutput { return o.ApplyT(func(v NonResourceRulePatch) []string { return v.NonResourceURLs }).(pulumi.StringArrayOutput) @@ -720,6 +835,12 @@ func (o NonResourceRulePatchArrayOutput) ToNonResourceRulePatchArrayOutputWithCo return o } +func (o NonResourceRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourceRulePatch] { + return pulumix.Output[[]NonResourceRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourceRulePatchArrayOutput) Index(i pulumi.IntInput) NonResourceRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourceRulePatch { return vs[0].([]NonResourceRulePatch)[vs[1].(int)] @@ -785,6 +906,12 @@ func (i ResourceAttributesArgs) ToResourceAttributesOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesOutput) } +func (i ResourceAttributesArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributes] { + return pulumix.Output[ResourceAttributes]{ + OutputState: i.ToResourceAttributesOutputWithContext(ctx).OutputState, + } +} + func (i ResourceAttributesArgs) ToResourceAttributesPtrOutput() ResourceAttributesPtrOutput { return i.ToResourceAttributesPtrOutputWithContext(context.Background()) } @@ -826,6 +953,12 @@ func (i *resourceAttributesPtrType) ToResourceAttributesPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesPtrOutput) } +func (i *resourceAttributesPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributes] { + return pulumix.Output[*ResourceAttributes]{ + OutputState: i.ToResourceAttributesPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface type ResourceAttributesOutput struct{ *pulumi.OutputState } @@ -851,6 +984,12 @@ func (o ResourceAttributesOutput) ToResourceAttributesPtrOutputWithContext(ctx c }).(ResourceAttributesPtrOutput) } +func (o ResourceAttributesOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributes] { + return pulumix.Output[ResourceAttributes]{ + OutputState: o.OutputState, + } +} + // Group is the API Group of the Resource. "*" means all. func (o ResourceAttributesOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceAttributes) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -900,6 +1039,12 @@ func (o ResourceAttributesPtrOutput) ToResourceAttributesPtrOutputWithContext(ct return o } +func (o ResourceAttributesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributes] { + return pulumix.Output[*ResourceAttributes]{ + OutputState: o.OutputState, + } +} + func (o ResourceAttributesPtrOutput) Elem() ResourceAttributesOutput { return o.ApplyT(func(v *ResourceAttributes) ResourceAttributes { if v != nil { @@ -1039,6 +1184,12 @@ func (i ResourceAttributesPatchArgs) ToResourceAttributesPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesPatchOutput) } +func (i ResourceAttributesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributesPatch] { + return pulumix.Output[ResourceAttributesPatch]{ + OutputState: i.ToResourceAttributesPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceAttributesPatchArgs) ToResourceAttributesPatchPtrOutput() ResourceAttributesPatchPtrOutput { return i.ToResourceAttributesPatchPtrOutputWithContext(context.Background()) } @@ -1080,6 +1231,12 @@ func (i *resourceAttributesPatchPtrType) ToResourceAttributesPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ResourceAttributesPatchPtrOutput) } +func (i *resourceAttributesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributesPatch] { + return pulumix.Output[*ResourceAttributesPatch]{ + OutputState: i.ToResourceAttributesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface type ResourceAttributesPatchOutput struct{ *pulumi.OutputState } @@ -1105,6 +1262,12 @@ func (o ResourceAttributesPatchOutput) ToResourceAttributesPatchPtrOutputWithCon }).(ResourceAttributesPatchPtrOutput) } +func (o ResourceAttributesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceAttributesPatch] { + return pulumix.Output[ResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + // Group is the API Group of the Resource. "*" means all. func (o ResourceAttributesPatchOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceAttributesPatch) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -1154,6 +1317,12 @@ func (o ResourceAttributesPatchPtrOutput) ToResourceAttributesPatchPtrOutputWith return o } +func (o ResourceAttributesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceAttributesPatch] { + return pulumix.Output[*ResourceAttributesPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceAttributesPatchPtrOutput) Elem() ResourceAttributesPatchOutput { return o.ApplyT(func(v *ResourceAttributesPatch) ResourceAttributesPatch { if v != nil { @@ -1283,6 +1452,12 @@ func (i ResourceRuleArgs) ToResourceRuleOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(ResourceRuleOutput) } +func (i ResourceRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceRule] { + return pulumix.Output[ResourceRule]{ + OutputState: i.ToResourceRuleOutputWithContext(ctx).OutputState, + } +} + // ResourceRuleArrayInput is an input type that accepts ResourceRuleArray and ResourceRuleArrayOutput values. // You can construct a concrete instance of `ResourceRuleArrayInput` via: // @@ -1308,6 +1483,12 @@ func (i ResourceRuleArray) ToResourceRuleArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ResourceRuleArrayOutput) } +func (i ResourceRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRule] { + return pulumix.Output[[]ResourceRule]{ + OutputState: i.ToResourceRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. type ResourceRuleOutput struct{ *pulumi.OutputState } @@ -1323,6 +1504,12 @@ func (o ResourceRuleOutput) ToResourceRuleOutputWithContext(ctx context.Context) return o } +func (o ResourceRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceRule] { + return pulumix.Output[ResourceRule]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "*" means all. func (o ResourceRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourceRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1359,6 +1546,12 @@ func (o ResourceRuleArrayOutput) ToResourceRuleArrayOutputWithContext(ctx contex return o } +func (o ResourceRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRule] { + return pulumix.Output[[]ResourceRule]{ + OutputState: o.OutputState, + } +} + func (o ResourceRuleArrayOutput) Index(i pulumi.IntInput) ResourceRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceRule { return vs[0].([]ResourceRule)[vs[1].(int)] @@ -1414,6 +1607,12 @@ func (i ResourceRulePatchArgs) ToResourceRulePatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceRulePatchOutput) } +func (i ResourceRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceRulePatch] { + return pulumix.Output[ResourceRulePatch]{ + OutputState: i.ToResourceRulePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceRulePatchArrayInput is an input type that accepts ResourceRulePatchArray and ResourceRulePatchArrayOutput values. // You can construct a concrete instance of `ResourceRulePatchArrayInput` via: // @@ -1439,6 +1638,12 @@ func (i ResourceRulePatchArray) ToResourceRulePatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceRulePatchArrayOutput) } +func (i ResourceRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRulePatch] { + return pulumix.Output[[]ResourceRulePatch]{ + OutputState: i.ToResourceRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. type ResourceRulePatchOutput struct{ *pulumi.OutputState } @@ -1454,6 +1659,12 @@ func (o ResourceRulePatchOutput) ToResourceRulePatchOutputWithContext(ctx contex return o } +func (o ResourceRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceRulePatch] { + return pulumix.Output[ResourceRulePatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "*" means all. func (o ResourceRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourceRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1490,6 +1701,12 @@ func (o ResourceRulePatchArrayOutput) ToResourceRulePatchArrayOutputWithContext( return o } +func (o ResourceRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceRulePatch] { + return pulumix.Output[[]ResourceRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceRulePatchArrayOutput) Index(i pulumi.IntInput) ResourceRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceRulePatch { return vs[0].([]ResourceRulePatch)[vs[1].(int)] @@ -1545,6 +1762,12 @@ func (i SelfSubjectAccessReviewArgs) ToSelfSubjectAccessReviewOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewOutput) } +func (i SelfSubjectAccessReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReview] { + return pulumix.Output[SelfSubjectAccessReview]{ + OutputState: i.ToSelfSubjectAccessReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means "in all namespaces". Self is a special case, because users should always be able to check whether they can perform an action type SelfSubjectAccessReviewOutput struct{ *pulumi.OutputState } @@ -1560,6 +1783,12 @@ func (o SelfSubjectAccessReviewOutput) ToSelfSubjectAccessReviewOutputWithContex return o } +func (o SelfSubjectAccessReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReview] { + return pulumix.Output[SelfSubjectAccessReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectAccessReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1633,6 +1862,12 @@ func (i SelfSubjectAccessReviewPatchArgs) ToSelfSubjectAccessReviewPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewPatchOutput) } +func (i SelfSubjectAccessReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewPatch] { + return pulumix.Output[SelfSubjectAccessReviewPatch]{ + OutputState: i.ToSelfSubjectAccessReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means "in all namespaces". Self is a special case, because users should always be able to check whether they can perform an action type SelfSubjectAccessReviewPatchOutput struct{ *pulumi.OutputState } @@ -1648,6 +1883,12 @@ func (o SelfSubjectAccessReviewPatchOutput) ToSelfSubjectAccessReviewPatchOutput return o } +func (o SelfSubjectAccessReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewPatch] { + return pulumix.Output[SelfSubjectAccessReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectAccessReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1711,6 +1952,12 @@ func (i SelfSubjectAccessReviewSpecArgs) ToSelfSubjectAccessReviewSpecOutputWith return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewSpecOutput) } +func (i SelfSubjectAccessReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpec] { + return pulumix.Output[SelfSubjectAccessReviewSpec]{ + OutputState: i.ToSelfSubjectAccessReviewSpecOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SelfSubjectAccessReviewSpecOutput struct{ *pulumi.OutputState } @@ -1726,6 +1973,12 @@ func (o SelfSubjectAccessReviewSpecOutput) ToSelfSubjectAccessReviewSpecOutputWi return o } +func (o SelfSubjectAccessReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpec] { + return pulumix.Output[SelfSubjectAccessReviewSpec]{ + OutputState: o.OutputState, + } +} + // NonResourceAttributes describes information for a non-resource access request func (o SelfSubjectAccessReviewSpecOutput) NonResourceAttributes() NonResourceAttributesPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReviewSpec) *NonResourceAttributes { return v.NonResourceAttributes }).(NonResourceAttributesPtrOutput) @@ -1775,6 +2028,12 @@ func (i SelfSubjectAccessReviewSpecPatchArgs) ToSelfSubjectAccessReviewSpecPatch return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewSpecPatchOutput) } +func (i SelfSubjectAccessReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[SelfSubjectAccessReviewSpecPatch]{ + OutputState: i.ToSelfSubjectAccessReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectAccessReviewSpecPatchArgs) ToSelfSubjectAccessReviewSpecPatchPtrOutput() SelfSubjectAccessReviewSpecPatchPtrOutput { return i.ToSelfSubjectAccessReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -1816,6 +2075,12 @@ func (i *selfSubjectAccessReviewSpecPatchPtrType) ToSelfSubjectAccessReviewSpecP return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectAccessReviewSpecPatchPtrOutput) } +func (i *selfSubjectAccessReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[*SelfSubjectAccessReviewSpecPatch]{ + OutputState: i.ToSelfSubjectAccessReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SelfSubjectAccessReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -1841,6 +2106,12 @@ func (o SelfSubjectAccessReviewSpecPatchOutput) ToSelfSubjectAccessReviewSpecPat }).(SelfSubjectAccessReviewSpecPatchPtrOutput) } +func (o SelfSubjectAccessReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[SelfSubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // NonResourceAttributes describes information for a non-resource access request func (o SelfSubjectAccessReviewSpecPatchOutput) NonResourceAttributes() NonResourceAttributesPatchPtrOutput { return o.ApplyT(func(v SelfSubjectAccessReviewSpecPatch) *NonResourceAttributesPatch { return v.NonResourceAttributes }).(NonResourceAttributesPatchPtrOutput) @@ -1865,6 +2136,12 @@ func (o SelfSubjectAccessReviewSpecPatchPtrOutput) ToSelfSubjectAccessReviewSpec return o } +func (o SelfSubjectAccessReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectAccessReviewSpecPatch] { + return pulumix.Output[*SelfSubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectAccessReviewSpecPatchPtrOutput) Elem() SelfSubjectAccessReviewSpecPatchOutput { return o.ApplyT(func(v *SelfSubjectAccessReviewSpecPatch) SelfSubjectAccessReviewSpecPatch { if v != nil { @@ -1944,6 +2221,12 @@ func (i SelfSubjectRulesReviewArgs) ToSelfSubjectRulesReviewOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewOutput) } +func (i SelfSubjectRulesReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReview] { + return pulumix.Output[SelfSubjectRulesReview]{ + OutputState: i.ToSelfSubjectRulesReviewOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. type SelfSubjectRulesReviewOutput struct{ *pulumi.OutputState } @@ -1959,6 +2242,12 @@ func (o SelfSubjectRulesReviewOutput) ToSelfSubjectRulesReviewOutputWithContext( return o } +func (o SelfSubjectRulesReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReview] { + return pulumix.Output[SelfSubjectRulesReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectRulesReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2032,6 +2321,12 @@ func (i SelfSubjectRulesReviewPatchArgs) ToSelfSubjectRulesReviewPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewPatchOutput) } +func (i SelfSubjectRulesReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewPatch] { + return pulumix.Output[SelfSubjectRulesReviewPatch]{ + OutputState: i.ToSelfSubjectRulesReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. type SelfSubjectRulesReviewPatchOutput struct{ *pulumi.OutputState } @@ -2047,6 +2342,12 @@ func (o SelfSubjectRulesReviewPatchOutput) ToSelfSubjectRulesReviewPatchOutputWi return o } +func (o SelfSubjectRulesReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewPatch] { + return pulumix.Output[SelfSubjectRulesReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SelfSubjectRulesReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2104,6 +2405,12 @@ func (i SelfSubjectRulesReviewSpecArgs) ToSelfSubjectRulesReviewSpecOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewSpecOutput) } +func (i SelfSubjectRulesReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpec] { + return pulumix.Output[SelfSubjectRulesReviewSpec]{ + OutputState: i.ToSelfSubjectRulesReviewSpecOutputWithContext(ctx).OutputState, + } +} + type SelfSubjectRulesReviewSpecOutput struct{ *pulumi.OutputState } func (SelfSubjectRulesReviewSpecOutput) ElementType() reflect.Type { @@ -2118,6 +2425,12 @@ func (o SelfSubjectRulesReviewSpecOutput) ToSelfSubjectRulesReviewSpecOutputWith return o } +func (o SelfSubjectRulesReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpec] { + return pulumix.Output[SelfSubjectRulesReviewSpec]{ + OutputState: o.OutputState, + } +} + // Namespace to evaluate rules for. Required. func (o SelfSubjectRulesReviewSpecOutput) Namespace() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReviewSpec) *string { return v.Namespace }).(pulumi.StringPtrOutput) @@ -2156,6 +2469,12 @@ func (i SelfSubjectRulesReviewSpecPatchArgs) ToSelfSubjectRulesReviewSpecPatchOu return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewSpecPatchOutput) } +func (i SelfSubjectRulesReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[SelfSubjectRulesReviewSpecPatch]{ + OutputState: i.ToSelfSubjectRulesReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i SelfSubjectRulesReviewSpecPatchArgs) ToSelfSubjectRulesReviewSpecPatchPtrOutput() SelfSubjectRulesReviewSpecPatchPtrOutput { return i.ToSelfSubjectRulesReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -2197,6 +2516,12 @@ func (i *selfSubjectRulesReviewSpecPatchPtrType) ToSelfSubjectRulesReviewSpecPat return pulumi.ToOutputWithContext(ctx, i).(SelfSubjectRulesReviewSpecPatchPtrOutput) } +func (i *selfSubjectRulesReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[*SelfSubjectRulesReviewSpecPatch]{ + OutputState: i.ToSelfSubjectRulesReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + type SelfSubjectRulesReviewSpecPatchOutput struct{ *pulumi.OutputState } func (SelfSubjectRulesReviewSpecPatchOutput) ElementType() reflect.Type { @@ -2221,6 +2546,12 @@ func (o SelfSubjectRulesReviewSpecPatchOutput) ToSelfSubjectRulesReviewSpecPatch }).(SelfSubjectRulesReviewSpecPatchPtrOutput) } +func (o SelfSubjectRulesReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[SelfSubjectRulesReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // Namespace to evaluate rules for. Required. func (o SelfSubjectRulesReviewSpecPatchOutput) Namespace() pulumi.StringPtrOutput { return o.ApplyT(func(v SelfSubjectRulesReviewSpecPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) @@ -2240,6 +2571,12 @@ func (o SelfSubjectRulesReviewSpecPatchPtrOutput) ToSelfSubjectRulesReviewSpecPa return o } +func (o SelfSubjectRulesReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SelfSubjectRulesReviewSpecPatch] { + return pulumix.Output[*SelfSubjectRulesReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o SelfSubjectRulesReviewSpecPatchPtrOutput) Elem() SelfSubjectRulesReviewSpecPatchOutput { return o.ApplyT(func(v *SelfSubjectRulesReviewSpecPatch) SelfSubjectRulesReviewSpecPatch { if v != nil { @@ -2309,6 +2646,12 @@ func (i SubjectAccessReviewArgs) ToSubjectAccessReviewOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewOutput) } +func (i SubjectAccessReviewArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReview] { + return pulumix.Output[SubjectAccessReview]{ + OutputState: i.ToSubjectAccessReviewOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReview checks whether or not a user or group can perform an action. type SubjectAccessReviewOutput struct{ *pulumi.OutputState } @@ -2324,6 +2667,12 @@ func (o SubjectAccessReviewOutput) ToSubjectAccessReviewOutputWithContext(ctx co return o } +func (o SubjectAccessReviewOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReview] { + return pulumix.Output[SubjectAccessReview]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SubjectAccessReviewOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectAccessReview) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2397,6 +2746,12 @@ func (i SubjectAccessReviewPatchArgs) ToSubjectAccessReviewPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewPatchOutput) } +func (i SubjectAccessReviewPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewPatch] { + return pulumix.Output[SubjectAccessReviewPatch]{ + OutputState: i.ToSubjectAccessReviewPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReview checks whether or not a user or group can perform an action. type SubjectAccessReviewPatchOutput struct{ *pulumi.OutputState } @@ -2412,6 +2767,12 @@ func (o SubjectAccessReviewPatchOutput) ToSubjectAccessReviewPatchOutputWithCont return o } +func (o SubjectAccessReviewPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewPatch] { + return pulumix.Output[SubjectAccessReviewPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SubjectAccessReviewPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectAccessReviewPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2491,6 +2852,12 @@ func (i SubjectAccessReviewSpecArgs) ToSubjectAccessReviewSpecOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewSpecOutput) } +func (i SubjectAccessReviewSpecArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpec] { + return pulumix.Output[SubjectAccessReviewSpec]{ + OutputState: i.ToSubjectAccessReviewSpecOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SubjectAccessReviewSpecOutput struct{ *pulumi.OutputState } @@ -2506,6 +2873,12 @@ func (o SubjectAccessReviewSpecOutput) ToSubjectAccessReviewSpecOutputWithContex return o } +func (o SubjectAccessReviewSpecOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpec] { + return pulumix.Output[SubjectAccessReviewSpec]{ + OutputState: o.OutputState, + } +} + // Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. func (o SubjectAccessReviewSpecOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v SubjectAccessReviewSpec) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -2591,6 +2964,12 @@ func (i SubjectAccessReviewSpecPatchArgs) ToSubjectAccessReviewSpecPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewSpecPatchOutput) } +func (i SubjectAccessReviewSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpecPatch] { + return pulumix.Output[SubjectAccessReviewSpecPatch]{ + OutputState: i.ToSubjectAccessReviewSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i SubjectAccessReviewSpecPatchArgs) ToSubjectAccessReviewSpecPatchPtrOutput() SubjectAccessReviewSpecPatchPtrOutput { return i.ToSubjectAccessReviewSpecPatchPtrOutputWithContext(context.Background()) } @@ -2632,6 +3011,12 @@ func (i *subjectAccessReviewSpecPatchPtrType) ToSubjectAccessReviewSpecPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewSpecPatchPtrOutput) } +func (i *subjectAccessReviewSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewSpecPatch] { + return pulumix.Output[*SubjectAccessReviewSpecPatch]{ + OutputState: i.ToSubjectAccessReviewSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set type SubjectAccessReviewSpecPatchOutput struct{ *pulumi.OutputState } @@ -2657,6 +3042,12 @@ func (o SubjectAccessReviewSpecPatchOutput) ToSubjectAccessReviewSpecPatchPtrOut }).(SubjectAccessReviewSpecPatchPtrOutput) } +func (o SubjectAccessReviewSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewSpecPatch] { + return pulumix.Output[SubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + // Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. func (o SubjectAccessReviewSpecPatchOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v SubjectAccessReviewSpecPatch) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -2701,6 +3092,12 @@ func (o SubjectAccessReviewSpecPatchPtrOutput) ToSubjectAccessReviewSpecPatchPtr return o } +func (o SubjectAccessReviewSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewSpecPatch] { + return pulumix.Output[*SubjectAccessReviewSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectAccessReviewSpecPatchPtrOutput) Elem() SubjectAccessReviewSpecPatchOutput { return o.ApplyT(func(v *SubjectAccessReviewSpecPatch) SubjectAccessReviewSpecPatch { if v != nil { @@ -2818,6 +3215,12 @@ func (i SubjectAccessReviewStatusArgs) ToSubjectAccessReviewStatusOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusOutput) } +func (i SubjectAccessReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatus] { + return pulumix.Output[SubjectAccessReviewStatus]{ + OutputState: i.ToSubjectAccessReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SubjectAccessReviewStatusArgs) ToSubjectAccessReviewStatusPtrOutput() SubjectAccessReviewStatusPtrOutput { return i.ToSubjectAccessReviewStatusPtrOutputWithContext(context.Background()) } @@ -2859,6 +3262,12 @@ func (i *subjectAccessReviewStatusPtrType) ToSubjectAccessReviewStatusPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusPtrOutput) } +func (i *subjectAccessReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatus] { + return pulumix.Output[*SubjectAccessReviewStatus]{ + OutputState: i.ToSubjectAccessReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewStatus type SubjectAccessReviewStatusOutput struct{ *pulumi.OutputState } @@ -2884,6 +3293,12 @@ func (o SubjectAccessReviewStatusOutput) ToSubjectAccessReviewStatusPtrOutputWit }).(SubjectAccessReviewStatusPtrOutput) } +func (o SubjectAccessReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatus] { + return pulumix.Output[SubjectAccessReviewStatus]{ + OutputState: o.OutputState, + } +} + // Allowed is required. True if the action would be allowed, false otherwise. func (o SubjectAccessReviewStatusOutput) Allowed() pulumi.BoolOutput { return o.ApplyT(func(v SubjectAccessReviewStatus) bool { return v.Allowed }).(pulumi.BoolOutput) @@ -2918,6 +3333,12 @@ func (o SubjectAccessReviewStatusPtrOutput) ToSubjectAccessReviewStatusPtrOutput return o } +func (o SubjectAccessReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatus] { + return pulumix.Output[*SubjectAccessReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SubjectAccessReviewStatusPtrOutput) Elem() SubjectAccessReviewStatusOutput { return o.ApplyT(func(v *SubjectAccessReviewStatus) SubjectAccessReviewStatus { if v != nil { @@ -3015,6 +3436,12 @@ func (i SubjectAccessReviewStatusPatchArgs) ToSubjectAccessReviewStatusPatchOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusPatchOutput) } +func (i SubjectAccessReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatusPatch] { + return pulumix.Output[SubjectAccessReviewStatusPatch]{ + OutputState: i.ToSubjectAccessReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SubjectAccessReviewStatusPatchArgs) ToSubjectAccessReviewStatusPatchPtrOutput() SubjectAccessReviewStatusPatchPtrOutput { return i.ToSubjectAccessReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -3056,6 +3483,12 @@ func (i *subjectAccessReviewStatusPatchPtrType) ToSubjectAccessReviewStatusPatch return pulumi.ToOutputWithContext(ctx, i).(SubjectAccessReviewStatusPatchPtrOutput) } +func (i *subjectAccessReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatusPatch] { + return pulumix.Output[*SubjectAccessReviewStatusPatch]{ + OutputState: i.ToSubjectAccessReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectAccessReviewStatus type SubjectAccessReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -3081,6 +3514,12 @@ func (o SubjectAccessReviewStatusPatchOutput) ToSubjectAccessReviewStatusPatchPt }).(SubjectAccessReviewStatusPatchPtrOutput) } +func (o SubjectAccessReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectAccessReviewStatusPatch] { + return pulumix.Output[SubjectAccessReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // Allowed is required. True if the action would be allowed, false otherwise. func (o SubjectAccessReviewStatusPatchOutput) Allowed() pulumi.BoolPtrOutput { return o.ApplyT(func(v SubjectAccessReviewStatusPatch) *bool { return v.Allowed }).(pulumi.BoolPtrOutput) @@ -3115,6 +3554,12 @@ func (o SubjectAccessReviewStatusPatchPtrOutput) ToSubjectAccessReviewStatusPatc return o } +func (o SubjectAccessReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectAccessReviewStatusPatch] { + return pulumix.Output[*SubjectAccessReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectAccessReviewStatusPatchPtrOutput) Elem() SubjectAccessReviewStatusPatchOutput { return o.ApplyT(func(v *SubjectAccessReviewStatusPatch) SubjectAccessReviewStatusPatch { if v != nil { @@ -3212,6 +3657,12 @@ func (i SubjectRulesReviewStatusArgs) ToSubjectRulesReviewStatusOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusOutput) } +func (i SubjectRulesReviewStatusArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatus] { + return pulumix.Output[SubjectRulesReviewStatus]{ + OutputState: i.ToSubjectRulesReviewStatusOutputWithContext(ctx).OutputState, + } +} + func (i SubjectRulesReviewStatusArgs) ToSubjectRulesReviewStatusPtrOutput() SubjectRulesReviewStatusPtrOutput { return i.ToSubjectRulesReviewStatusPtrOutputWithContext(context.Background()) } @@ -3253,6 +3704,12 @@ func (i *subjectRulesReviewStatusPtrType) ToSubjectRulesReviewStatusPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusPtrOutput) } +func (i *subjectRulesReviewStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatus] { + return pulumix.Output[*SubjectRulesReviewStatus]{ + OutputState: i.ToSubjectRulesReviewStatusPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. type SubjectRulesReviewStatusOutput struct{ *pulumi.OutputState } @@ -3278,6 +3735,12 @@ func (o SubjectRulesReviewStatusOutput) ToSubjectRulesReviewStatusPtrOutputWithC }).(SubjectRulesReviewStatusPtrOutput) } +func (o SubjectRulesReviewStatusOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatus] { + return pulumix.Output[SubjectRulesReviewStatus]{ + OutputState: o.OutputState, + } +} + // EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. func (o SubjectRulesReviewStatusOutput) EvaluationError() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectRulesReviewStatus) *string { return v.EvaluationError }).(pulumi.StringPtrOutput) @@ -3312,6 +3775,12 @@ func (o SubjectRulesReviewStatusPtrOutput) ToSubjectRulesReviewStatusPtrOutputWi return o } +func (o SubjectRulesReviewStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatus] { + return pulumix.Output[*SubjectRulesReviewStatus]{ + OutputState: o.OutputState, + } +} + func (o SubjectRulesReviewStatusPtrOutput) Elem() SubjectRulesReviewStatusOutput { return o.ApplyT(func(v *SubjectRulesReviewStatus) SubjectRulesReviewStatus { if v != nil { @@ -3409,6 +3878,12 @@ func (i SubjectRulesReviewStatusPatchArgs) ToSubjectRulesReviewStatusPatchOutput return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusPatchOutput) } +func (i SubjectRulesReviewStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatusPatch] { + return pulumix.Output[SubjectRulesReviewStatusPatch]{ + OutputState: i.ToSubjectRulesReviewStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i SubjectRulesReviewStatusPatchArgs) ToSubjectRulesReviewStatusPatchPtrOutput() SubjectRulesReviewStatusPatchPtrOutput { return i.ToSubjectRulesReviewStatusPatchPtrOutputWithContext(context.Background()) } @@ -3450,6 +3925,12 @@ func (i *subjectRulesReviewStatusPatchPtrType) ToSubjectRulesReviewStatusPatchPt return pulumi.ToOutputWithContext(ctx, i).(SubjectRulesReviewStatusPatchPtrOutput) } +func (i *subjectRulesReviewStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatusPatch] { + return pulumix.Output[*SubjectRulesReviewStatusPatch]{ + OutputState: i.ToSubjectRulesReviewStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. type SubjectRulesReviewStatusPatchOutput struct{ *pulumi.OutputState } @@ -3475,6 +3956,12 @@ func (o SubjectRulesReviewStatusPatchOutput) ToSubjectRulesReviewStatusPatchPtrO }).(SubjectRulesReviewStatusPatchPtrOutput) } +func (o SubjectRulesReviewStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectRulesReviewStatusPatch] { + return pulumix.Output[SubjectRulesReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + // EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. func (o SubjectRulesReviewStatusPatchOutput) EvaluationError() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectRulesReviewStatusPatch) *string { return v.EvaluationError }).(pulumi.StringPtrOutput) @@ -3509,6 +3996,12 @@ func (o SubjectRulesReviewStatusPatchPtrOutput) ToSubjectRulesReviewStatusPatchP return o } +func (o SubjectRulesReviewStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SubjectRulesReviewStatusPatch] { + return pulumix.Output[*SubjectRulesReviewStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectRulesReviewStatusPatchPtrOutput) Elem() SubjectRulesReviewStatusPatchOutput { return o.ApplyT(func(v *SubjectRulesReviewStatusPatch) SubjectRulesReviewStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscaler.go b/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscaler.go index c361a830bc..b8da0c81f7 100644 --- a/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscaler.go +++ b/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscaler.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // configuration of a horizontal pod autoscaler. @@ -127,6 +128,12 @@ func (i *HorizontalPodAutoscaler) ToHorizontalPodAutoscalerOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerOutput) } +func (i *HorizontalPodAutoscaler) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerArrayInput is an input type that accepts HorizontalPodAutoscalerArray and HorizontalPodAutoscalerArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerArrayInput` via: // @@ -152,6 +159,12 @@ func (i HorizontalPodAutoscalerArray) ToHorizontalPodAutoscalerArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerArrayOutput) } +func (i HorizontalPodAutoscalerArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerMapInput is an input type that accepts HorizontalPodAutoscalerMap and HorizontalPodAutoscalerMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerMapInput` via: // @@ -177,6 +190,12 @@ func (i HorizontalPodAutoscalerMap) ToHorizontalPodAutoscalerMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerMapOutput) } +func (i HorizontalPodAutoscalerMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o HorizontalPodAutoscalerOutput) ToHorizontalPodAutoscalerOutputWithContex return o } +func (o HorizontalPodAutoscalerOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscaler) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o HorizontalPodAutoscalerArrayOutput) ToHorizontalPodAutoscalerArrayOutput return o } +func (o HorizontalPodAutoscalerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].([]*HorizontalPodAutoscaler)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o HorizontalPodAutoscalerMapOutput) ToHorizontalPodAutoscalerMapOutputWith return o } +func (o HorizontalPodAutoscalerMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].(map[string]*HorizontalPodAutoscaler)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerList.go b/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerList.go index 5022a82471..c93369695a 100644 --- a/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerList.go +++ b/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // list of horizontal pod autoscaler objects. @@ -117,6 +118,12 @@ func (i *HorizontalPodAutoscalerList) ToHorizontalPodAutoscalerListOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListOutput) } +func (i *HorizontalPodAutoscalerList) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListArrayInput is an input type that accepts HorizontalPodAutoscalerListArray and HorizontalPodAutoscalerListArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListArrayInput` via: // @@ -142,6 +149,12 @@ func (i HorizontalPodAutoscalerListArray) ToHorizontalPodAutoscalerListArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListArrayOutput) } +func (i HorizontalPodAutoscalerListArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListMapInput is an input type that accepts HorizontalPodAutoscalerListMap and HorizontalPodAutoscalerListMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListMapInput` via: // @@ -167,6 +180,12 @@ func (i HorizontalPodAutoscalerListMap) ToHorizontalPodAutoscalerListMapOutputWi return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListMapOutput) } +func (i HorizontalPodAutoscalerListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerListOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o HorizontalPodAutoscalerListOutput) ToHorizontalPodAutoscalerListOutputWi return o } +func (o HorizontalPodAutoscalerListOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o HorizontalPodAutoscalerListArrayOutput) ToHorizontalPodAutoscalerListArr return o } +func (o HorizontalPodAutoscalerListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].([]*HorizontalPodAutoscalerList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o HorizontalPodAutoscalerListMapOutput) ToHorizontalPodAutoscalerListMapOu return o } +func (o HorizontalPodAutoscalerListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].(map[string]*HorizontalPodAutoscalerList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerPatch.go b/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerPatch.go index 763b0eb421..956a4785e8 100644 --- a/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerPatch.go +++ b/sdk/go/kubernetes/autoscaling/v1/horizontalPodAutoscalerPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *HorizontalPodAutoscalerPatch) ToHorizontalPodAutoscalerPatchOutputWithC return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchOutput) } +func (i *HorizontalPodAutoscalerPatch) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchArrayInput is an input type that accepts HorizontalPodAutoscalerPatchArray and HorizontalPodAutoscalerPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i HorizontalPodAutoscalerPatchArray) ToHorizontalPodAutoscalerPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchArrayOutput) } +func (i HorizontalPodAutoscalerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchMapInput is an input type that accepts HorizontalPodAutoscalerPatchMap and HorizontalPodAutoscalerPatchMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i HorizontalPodAutoscalerPatchMap) ToHorizontalPodAutoscalerPatchMapOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchMapOutput) } +func (i HorizontalPodAutoscalerPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerPatchOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o HorizontalPodAutoscalerPatchOutput) ToHorizontalPodAutoscalerPatchOutput return o } +func (o HorizontalPodAutoscalerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o HorizontalPodAutoscalerPatchArrayOutput) ToHorizontalPodAutoscalerPatchA return o } +func (o HorizontalPodAutoscalerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].([]*HorizontalPodAutoscalerPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o HorizontalPodAutoscalerPatchMapOutput) ToHorizontalPodAutoscalerPatchMap return o } +func (o HorizontalPodAutoscalerPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].(map[string]*HorizontalPodAutoscalerPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v1/pulumiTypes.go b/sdk/go/kubernetes/autoscaling/v1/pulumiTypes.go index bd487809bc..88df80444f 100644 --- a/sdk/go/kubernetes/autoscaling/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/autoscaling/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -57,6 +58,12 @@ func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferenceOutputWith return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferenceOutput) } +func (i CrossVersionObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferencePtrOutput() CrossVersionObjectReferencePtrOutput { return i.ToCrossVersionObjectReferencePtrOutputWithContext(context.Background()) } @@ -98,6 +105,12 @@ func (i *crossVersionObjectReferencePtrType) ToCrossVersionObjectReferencePtrOut return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePtrOutput) } +func (i *crossVersionObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferenceOutput struct{ *pulumi.OutputState } @@ -123,6 +136,12 @@ func (o CrossVersionObjectReferenceOutput) ToCrossVersionObjectReferencePtrOutpu }).(CrossVersionObjectReferencePtrOutput) } +func (o CrossVersionObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + // apiVersion is the API version of the referent func (o CrossVersionObjectReferenceOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReference) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -152,6 +171,12 @@ func (o CrossVersionObjectReferencePtrOutput) ToCrossVersionObjectReferencePtrOu return o } +func (o CrossVersionObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePtrOutput) Elem() CrossVersionObjectReferenceOutput { return o.ApplyT(func(v *CrossVersionObjectReference) CrossVersionObjectReference { if v != nil { @@ -235,6 +260,12 @@ func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatch return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchOutput) } +func (i CrossVersionObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatchPtrOutput() CrossVersionObjectReferencePatchPtrOutput { return i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -276,6 +307,12 @@ func (i *crossVersionObjectReferencePatchPtrType) ToCrossVersionObjectReferenceP return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchPtrOutput) } +func (i *crossVersionObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -301,6 +338,12 @@ func (o CrossVersionObjectReferencePatchOutput) ToCrossVersionObjectReferencePat }).(CrossVersionObjectReferencePatchPtrOutput) } +func (o CrossVersionObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // apiVersion is the API version of the referent func (o CrossVersionObjectReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -330,6 +373,12 @@ func (o CrossVersionObjectReferencePatchPtrOutput) ToCrossVersionObjectReference return o } +func (o CrossVersionObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePatchPtrOutput) Elem() CrossVersionObjectReferencePatchOutput { return o.ApplyT(func(v *CrossVersionObjectReferencePatch) CrossVersionObjectReferencePatch { if v != nil { @@ -421,6 +470,12 @@ func (i HorizontalPodAutoscalerTypeArgs) ToHorizontalPodAutoscalerTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeOutput) } +func (i HorizontalPodAutoscalerTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerTypeArrayInput is an input type that accepts HorizontalPodAutoscalerTypeArray and HorizontalPodAutoscalerTypeArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerTypeArrayInput` via: // @@ -446,6 +501,12 @@ func (i HorizontalPodAutoscalerTypeArray) ToHorizontalPodAutoscalerTypeArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeArrayOutput) } +func (i HorizontalPodAutoscalerTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeArrayOutputWithContext(ctx).OutputState, + } +} + // configuration of a horizontal pod autoscaler. type HorizontalPodAutoscalerTypeOutput struct{ *pulumi.OutputState } @@ -461,6 +522,12 @@ func (o HorizontalPodAutoscalerTypeOutput) ToHorizontalPodAutoscalerTypeOutputWi return o } +func (o HorizontalPodAutoscalerTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -500,6 +567,12 @@ func (o HorizontalPodAutoscalerTypeArrayOutput) ToHorizontalPodAutoscalerTypeArr return o } +func (o HorizontalPodAutoscalerTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerTypeArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerType { return vs[0].([]HorizontalPodAutoscalerType)[vs[1].(int)] @@ -553,6 +626,12 @@ func (i HorizontalPodAutoscalerListTypeArgs) ToHorizontalPodAutoscalerListTypeOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListTypeOutput) } +func (i HorizontalPodAutoscalerListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: i.ToHorizontalPodAutoscalerListTypeOutputWithContext(ctx).OutputState, + } +} + // list of horizontal pod autoscaler objects. type HorizontalPodAutoscalerListTypeOutput struct{ *pulumi.OutputState } @@ -568,6 +647,12 @@ func (o HorizontalPodAutoscalerListTypeOutput) ToHorizontalPodAutoscalerListType return o } +func (o HorizontalPodAutoscalerListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -639,6 +724,12 @@ func (i HorizontalPodAutoscalerPatchTypeArgs) ToHorizontalPodAutoscalerPatchType return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchTypeOutput) } +func (i HorizontalPodAutoscalerPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: i.ToHorizontalPodAutoscalerPatchTypeOutputWithContext(ctx).OutputState, + } +} + // configuration of a horizontal pod autoscaler. type HorizontalPodAutoscalerPatchTypeOutput struct{ *pulumi.OutputState } @@ -654,6 +745,12 @@ func (o HorizontalPodAutoscalerPatchTypeOutput) ToHorizontalPodAutoscalerPatchTy return o } +func (o HorizontalPodAutoscalerPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -726,6 +823,12 @@ func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecOutput) } +func (i HorizontalPodAutoscalerSpecArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecPtrOutput() HorizontalPodAutoscalerSpecPtrOutput { return i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(context.Background()) } @@ -767,6 +870,12 @@ func (i *horizontalPodAutoscalerSpecPtrType) ToHorizontalPodAutoscalerSpecPtrOut return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPtrOutput) } +func (i *horizontalPodAutoscalerSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(ctx).OutputState, + } +} + // specification of a horizontal pod autoscaler. type HorizontalPodAutoscalerSpecOutput struct{ *pulumi.OutputState } @@ -792,6 +901,12 @@ func (o HorizontalPodAutoscalerSpecOutput) ToHorizontalPodAutoscalerSpecPtrOutpu }).(HorizontalPodAutoscalerSpecPtrOutput) } +func (o HorizontalPodAutoscalerSpecOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + // maxReplicas is the upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas. func (o HorizontalPodAutoscalerSpecOutput) MaxReplicas() pulumi.IntOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpec) int { return v.MaxReplicas }).(pulumi.IntOutput) @@ -826,6 +941,12 @@ func (o HorizontalPodAutoscalerSpecPtrOutput) ToHorizontalPodAutoscalerSpecPtrOu return o } +func (o HorizontalPodAutoscalerSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPtrOutput) Elem() HorizontalPodAutoscalerSpecOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpec) HorizontalPodAutoscalerSpec { if v != nil { @@ -923,6 +1044,12 @@ func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatch return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchOutput) } +func (i HorizontalPodAutoscalerSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatchPtrOutput() HorizontalPodAutoscalerSpecPatchPtrOutput { return i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(context.Background()) } @@ -964,6 +1091,12 @@ func (i *horizontalPodAutoscalerSpecPatchPtrType) ToHorizontalPodAutoscalerSpecP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (i *horizontalPodAutoscalerSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // specification of a horizontal pod autoscaler. type HorizontalPodAutoscalerSpecPatchOutput struct{ *pulumi.OutputState } @@ -989,6 +1122,12 @@ func (o HorizontalPodAutoscalerSpecPatchOutput) ToHorizontalPodAutoscalerSpecPat }).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (o HorizontalPodAutoscalerSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + // maxReplicas is the upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas. func (o HorizontalPodAutoscalerSpecPatchOutput) MaxReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpecPatch) *int { return v.MaxReplicas }).(pulumi.IntPtrOutput) @@ -1023,6 +1162,12 @@ func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToHorizontalPodAutoscalerSpec return o } +func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPatchPtrOutput) Elem() HorizontalPodAutoscalerSpecPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpecPatch) HorizontalPodAutoscalerSpecPatch { if v != nil { @@ -1124,6 +1269,12 @@ func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusOutput) } +func (i HorizontalPodAutoscalerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusPtrOutput() HorizontalPodAutoscalerStatusPtrOutput { return i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(context.Background()) } @@ -1165,6 +1316,12 @@ func (i *horizontalPodAutoscalerStatusPtrType) ToHorizontalPodAutoscalerStatusPt return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPtrOutput) } +func (i *horizontalPodAutoscalerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // current status of a horizontal pod autoscaler type HorizontalPodAutoscalerStatusOutput struct{ *pulumi.OutputState } @@ -1190,6 +1347,12 @@ func (o HorizontalPodAutoscalerStatusOutput) ToHorizontalPodAutoscalerStatusPtrO }).(HorizontalPodAutoscalerStatusPtrOutput) } +func (o HorizontalPodAutoscalerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + // currentCPUUtilizationPercentage is the current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU. func (o HorizontalPodAutoscalerStatusOutput) CurrentCPUUtilizationPercentage() pulumi.IntPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatus) *int { return v.CurrentCPUUtilizationPercentage }).(pulumi.IntPtrOutput) @@ -1229,6 +1392,12 @@ func (o HorizontalPodAutoscalerStatusPtrOutput) ToHorizontalPodAutoscalerStatusP return o } +func (o HorizontalPodAutoscalerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPtrOutput) Elem() HorizontalPodAutoscalerStatusOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatus) HorizontalPodAutoscalerStatus { if v != nil { @@ -1340,6 +1509,12 @@ func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchOutput) } +func (i HorizontalPodAutoscalerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusPatchPtrOutput() HorizontalPodAutoscalerStatusPatchPtrOutput { return i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(context.Background()) } @@ -1381,6 +1556,12 @@ func (i *horizontalPodAutoscalerStatusPatchPtrType) ToHorizontalPodAutoscalerSta return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (i *horizontalPodAutoscalerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // current status of a horizontal pod autoscaler type HorizontalPodAutoscalerStatusPatchOutput struct{ *pulumi.OutputState } @@ -1406,6 +1587,12 @@ func (o HorizontalPodAutoscalerStatusPatchOutput) ToHorizontalPodAutoscalerStatu }).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (o HorizontalPodAutoscalerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + // currentCPUUtilizationPercentage is the current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU. func (o HorizontalPodAutoscalerStatusPatchOutput) CurrentCPUUtilizationPercentage() pulumi.IntPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatusPatch) *int { return v.CurrentCPUUtilizationPercentage }).(pulumi.IntPtrOutput) @@ -1445,6 +1632,12 @@ func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToHorizontalPodAutoscalerSt return o } +func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPatchPtrOutput) Elem() HorizontalPodAutoscalerStatusPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatusPatch) HorizontalPodAutoscalerStatusPatch { if v != nil { @@ -1556,6 +1749,12 @@ func (i ScaleArgs) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return pulumi.ToOutputWithContext(ctx, i).(ScaleOutput) } +func (i ScaleArgs) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: i.ToScaleOutputWithContext(ctx).OutputState, + } +} + // Scale represents a scaling request for a resource. type ScaleOutput struct{ *pulumi.OutputState } @@ -1571,6 +1770,12 @@ func (o ScaleOutput) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return o } +func (o ScaleOutput) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScaleOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Scale) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1647,6 +1852,12 @@ func (i ScalePatchArgs) ToScalePatchOutputWithContext(ctx context.Context) Scale return pulumi.ToOutputWithContext(ctx, i).(ScalePatchOutput) } +func (i ScalePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: i.ToScalePatchOutputWithContext(ctx).OutputState, + } +} + // Scale represents a scaling request for a resource. type ScalePatchOutput struct{ *pulumi.OutputState } @@ -1662,6 +1873,12 @@ func (o ScalePatchOutput) ToScalePatchOutputWithContext(ctx context.Context) Sca return o } +func (o ScalePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScalePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ScalePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1722,6 +1939,12 @@ func (i ScaleSpecArgs) ToScaleSpecOutputWithContext(ctx context.Context) ScaleSp return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecOutput) } +func (i ScaleSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: i.ToScaleSpecOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecArgs) ToScaleSpecPtrOutput() ScaleSpecPtrOutput { return i.ToScaleSpecPtrOutputWithContext(context.Background()) } @@ -1763,6 +1986,12 @@ func (i *scaleSpecPtrType) ToScaleSpecPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPtrOutput) } +func (i *scaleSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: i.ToScaleSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleSpec describes the attributes of a scale subresource. type ScaleSpecOutput struct{ *pulumi.OutputState } @@ -1788,6 +2017,12 @@ func (o ScaleSpecOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) Sc }).(ScaleSpecPtrOutput) } +func (o ScaleSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: o.OutputState, + } +} + // replicas is the desired number of instances for the scaled object. func (o ScaleSpecOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpec) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -1807,6 +2042,12 @@ func (o ScaleSpecPtrOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) return o } +func (o ScaleSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPtrOutput) Elem() ScaleSpecOutput { return o.ApplyT(func(v *ScaleSpec) ScaleSpec { if v != nil { @@ -1862,6 +2103,12 @@ func (i ScaleSpecPatchArgs) ToScaleSpecPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchOutput) } +func (i ScaleSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecPatchArgs) ToScaleSpecPatchPtrOutput() ScaleSpecPatchPtrOutput { return i.ToScaleSpecPatchPtrOutputWithContext(context.Background()) } @@ -1903,6 +2150,12 @@ func (i *scaleSpecPatchPtrType) ToScaleSpecPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchPtrOutput) } +func (i *scaleSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleSpec describes the attributes of a scale subresource. type ScaleSpecPatchOutput struct{ *pulumi.OutputState } @@ -1928,6 +2181,12 @@ func (o ScaleSpecPatchOutput) ToScaleSpecPatchPtrOutputWithContext(ctx context.C }).(ScaleSpecPatchPtrOutput) } +func (o ScaleSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + // replicas is the desired number of instances for the scaled object. func (o ScaleSpecPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpecPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -1947,6 +2206,12 @@ func (o ScaleSpecPatchPtrOutput) ToScaleSpecPatchPtrOutputWithContext(ctx contex return o } +func (o ScaleSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPatchPtrOutput) Elem() ScaleSpecPatchOutput { return o.ApplyT(func(v *ScaleSpecPatch) ScaleSpecPatch { if v != nil { @@ -2006,6 +2271,12 @@ func (i ScaleStatusArgs) ToScaleStatusOutputWithContext(ctx context.Context) Sca return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusOutput) } +func (i ScaleStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: i.ToScaleStatusOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusArgs) ToScaleStatusPtrOutput() ScaleStatusPtrOutput { return i.ToScaleStatusPtrOutputWithContext(context.Background()) } @@ -2047,6 +2318,12 @@ func (i *scaleStatusPtrType) ToScaleStatusPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPtrOutput) } +func (i *scaleStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: i.ToScaleStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleStatus represents the current status of a scale subresource. type ScaleStatusOutput struct{ *pulumi.OutputState } @@ -2072,6 +2349,12 @@ func (o ScaleStatusOutput) ToScaleStatusPtrOutputWithContext(ctx context.Context }).(ScaleStatusPtrOutput) } +func (o ScaleStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: o.OutputState, + } +} + // replicas is the actual number of observed instances of the scaled object. func (o ScaleStatusOutput) Replicas() pulumi.IntOutput { return o.ApplyT(func(v ScaleStatus) int { return v.Replicas }).(pulumi.IntOutput) @@ -2096,6 +2379,12 @@ func (o ScaleStatusPtrOutput) ToScaleStatusPtrOutputWithContext(ctx context.Cont return o } +func (o ScaleStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPtrOutput) Elem() ScaleStatusOutput { return o.ApplyT(func(v *ScaleStatus) ScaleStatus { if v != nil { @@ -2165,6 +2454,12 @@ func (i ScaleStatusPatchArgs) ToScaleStatusPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchOutput) } +func (i ScaleStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusPatchArgs) ToScaleStatusPatchPtrOutput() ScaleStatusPatchPtrOutput { return i.ToScaleStatusPatchPtrOutputWithContext(context.Background()) } @@ -2206,6 +2501,12 @@ func (i *scaleStatusPatchPtrType) ToScaleStatusPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchPtrOutput) } +func (i *scaleStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleStatus represents the current status of a scale subresource. type ScaleStatusPatchOutput struct{ *pulumi.OutputState } @@ -2231,6 +2532,12 @@ func (o ScaleStatusPatchOutput) ToScaleStatusPatchPtrOutputWithContext(ctx conte }).(ScaleStatusPatchPtrOutput) } +func (o ScaleStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + // replicas is the actual number of observed instances of the scaled object. func (o ScaleStatusPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleStatusPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -2255,6 +2562,12 @@ func (o ScaleStatusPatchPtrOutput) ToScaleStatusPatchPtrOutputWithContext(ctx co return o } +func (o ScaleStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPatchPtrOutput) Elem() ScaleStatusPatchOutput { return o.ApplyT(func(v *ScaleStatusPatch) ScaleStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscaler.go b/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscaler.go index 43f43e7ef5..78ec1ad2a7 100644 --- a/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscaler.go +++ b/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscaler.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. @@ -127,6 +128,12 @@ func (i *HorizontalPodAutoscaler) ToHorizontalPodAutoscalerOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerOutput) } +func (i *HorizontalPodAutoscaler) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerArrayInput is an input type that accepts HorizontalPodAutoscalerArray and HorizontalPodAutoscalerArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerArrayInput` via: // @@ -152,6 +159,12 @@ func (i HorizontalPodAutoscalerArray) ToHorizontalPodAutoscalerArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerArrayOutput) } +func (i HorizontalPodAutoscalerArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerMapInput is an input type that accepts HorizontalPodAutoscalerMap and HorizontalPodAutoscalerMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerMapInput` via: // @@ -177,6 +190,12 @@ func (i HorizontalPodAutoscalerMap) ToHorizontalPodAutoscalerMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerMapOutput) } +func (i HorizontalPodAutoscalerMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o HorizontalPodAutoscalerOutput) ToHorizontalPodAutoscalerOutputWithContex return o } +func (o HorizontalPodAutoscalerOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscaler) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o HorizontalPodAutoscalerArrayOutput) ToHorizontalPodAutoscalerArrayOutput return o } +func (o HorizontalPodAutoscalerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].([]*HorizontalPodAutoscaler)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o HorizontalPodAutoscalerMapOutput) ToHorizontalPodAutoscalerMapOutputWith return o } +func (o HorizontalPodAutoscalerMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].(map[string]*HorizontalPodAutoscaler)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerList.go b/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerList.go index 042a2cdc5a..2c72ec1113 100644 --- a/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerList.go +++ b/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. @@ -117,6 +118,12 @@ func (i *HorizontalPodAutoscalerList) ToHorizontalPodAutoscalerListOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListOutput) } +func (i *HorizontalPodAutoscalerList) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListArrayInput is an input type that accepts HorizontalPodAutoscalerListArray and HorizontalPodAutoscalerListArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListArrayInput` via: // @@ -142,6 +149,12 @@ func (i HorizontalPodAutoscalerListArray) ToHorizontalPodAutoscalerListArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListArrayOutput) } +func (i HorizontalPodAutoscalerListArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListMapInput is an input type that accepts HorizontalPodAutoscalerListMap and HorizontalPodAutoscalerListMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListMapInput` via: // @@ -167,6 +180,12 @@ func (i HorizontalPodAutoscalerListMap) ToHorizontalPodAutoscalerListMapOutputWi return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListMapOutput) } +func (i HorizontalPodAutoscalerListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerListOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o HorizontalPodAutoscalerListOutput) ToHorizontalPodAutoscalerListOutputWi return o } +func (o HorizontalPodAutoscalerListOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o HorizontalPodAutoscalerListArrayOutput) ToHorizontalPodAutoscalerListArr return o } +func (o HorizontalPodAutoscalerListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].([]*HorizontalPodAutoscalerList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o HorizontalPodAutoscalerListMapOutput) ToHorizontalPodAutoscalerListMapOu return o } +func (o HorizontalPodAutoscalerListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].(map[string]*HorizontalPodAutoscalerList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerPatch.go b/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerPatch.go index 214bb018ec..72c957f398 100644 --- a/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerPatch.go +++ b/sdk/go/kubernetes/autoscaling/v2/horizontalPodAutoscalerPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *HorizontalPodAutoscalerPatch) ToHorizontalPodAutoscalerPatchOutputWithC return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchOutput) } +func (i *HorizontalPodAutoscalerPatch) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchArrayInput is an input type that accepts HorizontalPodAutoscalerPatchArray and HorizontalPodAutoscalerPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i HorizontalPodAutoscalerPatchArray) ToHorizontalPodAutoscalerPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchArrayOutput) } +func (i HorizontalPodAutoscalerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchMapInput is an input type that accepts HorizontalPodAutoscalerPatchMap and HorizontalPodAutoscalerPatchMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i HorizontalPodAutoscalerPatchMap) ToHorizontalPodAutoscalerPatchMapOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchMapOutput) } +func (i HorizontalPodAutoscalerPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerPatchOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o HorizontalPodAutoscalerPatchOutput) ToHorizontalPodAutoscalerPatchOutput return o } +func (o HorizontalPodAutoscalerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o HorizontalPodAutoscalerPatchArrayOutput) ToHorizontalPodAutoscalerPatchA return o } +func (o HorizontalPodAutoscalerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].([]*HorizontalPodAutoscalerPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o HorizontalPodAutoscalerPatchMapOutput) ToHorizontalPodAutoscalerPatchMap return o } +func (o HorizontalPodAutoscalerPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].(map[string]*HorizontalPodAutoscalerPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2/pulumiTypes.go b/sdk/go/kubernetes/autoscaling/v2/pulumiTypes.go index e16508decb..a028fb7dd9 100644 --- a/sdk/go/kubernetes/autoscaling/v2/pulumiTypes.go +++ b/sdk/go/kubernetes/autoscaling/v2/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -57,6 +58,12 @@ func (i ContainerResourceMetricSourceArgs) ToContainerResourceMetricSourceOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourceOutput) } +func (i ContainerResourceMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSource] { + return pulumix.Output[ContainerResourceMetricSource]{ + OutputState: i.ToContainerResourceMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricSourceArgs) ToContainerResourceMetricSourcePtrOutput() ContainerResourceMetricSourcePtrOutput { return i.ToContainerResourceMetricSourcePtrOutputWithContext(context.Background()) } @@ -98,6 +105,12 @@ func (i *containerResourceMetricSourcePtrType) ToContainerResourceMetricSourcePt return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePtrOutput) } +func (i *containerResourceMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSource] { + return pulumix.Output[*ContainerResourceMetricSource]{ + OutputState: i.ToContainerResourceMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ContainerResourceMetricSourceOutput struct{ *pulumi.OutputState } @@ -123,6 +136,12 @@ func (o ContainerResourceMetricSourceOutput) ToContainerResourceMetricSourcePtrO }).(ContainerResourceMetricSourcePtrOutput) } +func (o ContainerResourceMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSource] { + return pulumix.Output[ContainerResourceMetricSource]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricSourceOutput) Container() pulumi.StringOutput { return o.ApplyT(func(v ContainerResourceMetricSource) string { return v.Container }).(pulumi.StringOutput) @@ -152,6 +171,12 @@ func (o ContainerResourceMetricSourcePtrOutput) ToContainerResourceMetricSourceP return o } +func (o ContainerResourceMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSource] { + return pulumix.Output[*ContainerResourceMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricSourcePtrOutput) Elem() ContainerResourceMetricSourceOutput { return o.ApplyT(func(v *ContainerResourceMetricSource) ContainerResourceMetricSource { if v != nil { @@ -235,6 +260,12 @@ func (i ContainerResourceMetricSourcePatchArgs) ToContainerResourceMetricSourceP return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePatchOutput) } +func (i ContainerResourceMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSourcePatch] { + return pulumix.Output[ContainerResourceMetricSourcePatch]{ + OutputState: i.ToContainerResourceMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricSourcePatchArgs) ToContainerResourceMetricSourcePatchPtrOutput() ContainerResourceMetricSourcePatchPtrOutput { return i.ToContainerResourceMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -276,6 +307,12 @@ func (i *containerResourceMetricSourcePatchPtrType) ToContainerResourceMetricSou return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePatchPtrOutput) } +func (i *containerResourceMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSourcePatch] { + return pulumix.Output[*ContainerResourceMetricSourcePatch]{ + OutputState: i.ToContainerResourceMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ContainerResourceMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -301,6 +338,12 @@ func (o ContainerResourceMetricSourcePatchOutput) ToContainerResourceMetricSourc }).(ContainerResourceMetricSourcePatchPtrOutput) } +func (o ContainerResourceMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSourcePatch] { + return pulumix.Output[ContainerResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricSourcePatchOutput) Container() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResourceMetricSourcePatch) *string { return v.Container }).(pulumi.StringPtrOutput) @@ -330,6 +373,12 @@ func (o ContainerResourceMetricSourcePatchPtrOutput) ToContainerResourceMetricSo return o } +func (o ContainerResourceMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSourcePatch] { + return pulumix.Output[*ContainerResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricSourcePatchPtrOutput) Elem() ContainerResourceMetricSourcePatchOutput { return o.ApplyT(func(v *ContainerResourceMetricSourcePatch) ContainerResourceMetricSourcePatch { if v != nil { @@ -413,6 +462,12 @@ func (i ContainerResourceMetricStatusArgs) ToContainerResourceMetricStatusOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusOutput) } +func (i ContainerResourceMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatus] { + return pulumix.Output[ContainerResourceMetricStatus]{ + OutputState: i.ToContainerResourceMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricStatusArgs) ToContainerResourceMetricStatusPtrOutput() ContainerResourceMetricStatusPtrOutput { return i.ToContainerResourceMetricStatusPtrOutputWithContext(context.Background()) } @@ -454,6 +509,12 @@ func (i *containerResourceMetricStatusPtrType) ToContainerResourceMetricStatusPt return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPtrOutput) } +func (i *containerResourceMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatus] { + return pulumix.Output[*ContainerResourceMetricStatus]{ + OutputState: i.ToContainerResourceMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ContainerResourceMetricStatusOutput struct{ *pulumi.OutputState } @@ -479,6 +540,12 @@ func (o ContainerResourceMetricStatusOutput) ToContainerResourceMetricStatusPtrO }).(ContainerResourceMetricStatusPtrOutput) } +func (o ContainerResourceMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatus] { + return pulumix.Output[ContainerResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricStatusOutput) Container() pulumi.StringOutput { return o.ApplyT(func(v ContainerResourceMetricStatus) string { return v.Container }).(pulumi.StringOutput) @@ -508,6 +575,12 @@ func (o ContainerResourceMetricStatusPtrOutput) ToContainerResourceMetricStatusP return o } +func (o ContainerResourceMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatus] { + return pulumix.Output[*ContainerResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricStatusPtrOutput) Elem() ContainerResourceMetricStatusOutput { return o.ApplyT(func(v *ContainerResourceMetricStatus) ContainerResourceMetricStatus { if v != nil { @@ -591,6 +664,12 @@ func (i ContainerResourceMetricStatusPatchArgs) ToContainerResourceMetricStatusP return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPatchOutput) } +func (i ContainerResourceMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatusPatch] { + return pulumix.Output[ContainerResourceMetricStatusPatch]{ + OutputState: i.ToContainerResourceMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricStatusPatchArgs) ToContainerResourceMetricStatusPatchPtrOutput() ContainerResourceMetricStatusPatchPtrOutput { return i.ToContainerResourceMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -632,6 +711,12 @@ func (i *containerResourceMetricStatusPatchPtrType) ToContainerResourceMetricSta return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPatchPtrOutput) } +func (i *containerResourceMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatusPatch] { + return pulumix.Output[*ContainerResourceMetricStatusPatch]{ + OutputState: i.ToContainerResourceMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ContainerResourceMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -657,6 +742,12 @@ func (o ContainerResourceMetricStatusPatchOutput) ToContainerResourceMetricStatu }).(ContainerResourceMetricStatusPatchPtrOutput) } +func (o ContainerResourceMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatusPatch] { + return pulumix.Output[ContainerResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricStatusPatchOutput) Container() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResourceMetricStatusPatch) *string { return v.Container }).(pulumi.StringPtrOutput) @@ -686,6 +777,12 @@ func (o ContainerResourceMetricStatusPatchPtrOutput) ToContainerResourceMetricSt return o } +func (o ContainerResourceMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatusPatch] { + return pulumix.Output[*ContainerResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricStatusPatchPtrOutput) Elem() ContainerResourceMetricStatusPatchOutput { return o.ApplyT(func(v *ContainerResourceMetricStatusPatch) ContainerResourceMetricStatusPatch { if v != nil { @@ -769,6 +866,12 @@ func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferenceOutputWith return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferenceOutput) } +func (i CrossVersionObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferencePtrOutput() CrossVersionObjectReferencePtrOutput { return i.ToCrossVersionObjectReferencePtrOutputWithContext(context.Background()) } @@ -810,6 +913,12 @@ func (i *crossVersionObjectReferencePtrType) ToCrossVersionObjectReferencePtrOut return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePtrOutput) } +func (i *crossVersionObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferenceOutput struct{ *pulumi.OutputState } @@ -835,6 +944,12 @@ func (o CrossVersionObjectReferenceOutput) ToCrossVersionObjectReferencePtrOutpu }).(CrossVersionObjectReferencePtrOutput) } +func (o CrossVersionObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + // apiVersion is the API version of the referent func (o CrossVersionObjectReferenceOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReference) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -864,6 +979,12 @@ func (o CrossVersionObjectReferencePtrOutput) ToCrossVersionObjectReferencePtrOu return o } +func (o CrossVersionObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePtrOutput) Elem() CrossVersionObjectReferenceOutput { return o.ApplyT(func(v *CrossVersionObjectReference) CrossVersionObjectReference { if v != nil { @@ -947,6 +1068,12 @@ func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatch return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchOutput) } +func (i CrossVersionObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatchPtrOutput() CrossVersionObjectReferencePatchPtrOutput { return i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -988,6 +1115,12 @@ func (i *crossVersionObjectReferencePatchPtrType) ToCrossVersionObjectReferenceP return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchPtrOutput) } +func (i *crossVersionObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -1013,6 +1146,12 @@ func (o CrossVersionObjectReferencePatchOutput) ToCrossVersionObjectReferencePat }).(CrossVersionObjectReferencePatchPtrOutput) } +func (o CrossVersionObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // apiVersion is the API version of the referent func (o CrossVersionObjectReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1042,6 +1181,12 @@ func (o CrossVersionObjectReferencePatchPtrOutput) ToCrossVersionObjectReference return o } +func (o CrossVersionObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePatchPtrOutput) Elem() CrossVersionObjectReferencePatchOutput { return o.ApplyT(func(v *CrossVersionObjectReferencePatch) CrossVersionObjectReferencePatch { if v != nil { @@ -1121,6 +1266,12 @@ func (i ExternalMetricSourceArgs) ToExternalMetricSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourceOutput) } +func (i ExternalMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSource] { + return pulumix.Output[ExternalMetricSource]{ + OutputState: i.ToExternalMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricSourceArgs) ToExternalMetricSourcePtrOutput() ExternalMetricSourcePtrOutput { return i.ToExternalMetricSourcePtrOutputWithContext(context.Background()) } @@ -1162,6 +1313,12 @@ func (i *externalMetricSourcePtrType) ToExternalMetricSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePtrOutput) } +func (i *externalMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSource] { + return pulumix.Output[*ExternalMetricSource]{ + OutputState: i.ToExternalMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). type ExternalMetricSourceOutput struct{ *pulumi.OutputState } @@ -1187,6 +1344,12 @@ func (o ExternalMetricSourceOutput) ToExternalMetricSourcePtrOutputWithContext(c }).(ExternalMetricSourcePtrOutput) } +func (o ExternalMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSource] { + return pulumix.Output[ExternalMetricSource]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o ExternalMetricSourceOutput) Metric() MetricIdentifierOutput { return o.ApplyT(func(v ExternalMetricSource) MetricIdentifier { return v.Metric }).(MetricIdentifierOutput) @@ -1211,6 +1374,12 @@ func (o ExternalMetricSourcePtrOutput) ToExternalMetricSourcePtrOutputWithContex return o } +func (o ExternalMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSource] { + return pulumix.Output[*ExternalMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricSourcePtrOutput) Elem() ExternalMetricSourceOutput { return o.ApplyT(func(v *ExternalMetricSource) ExternalMetricSource { if v != nil { @@ -1280,6 +1449,12 @@ func (i ExternalMetricSourcePatchArgs) ToExternalMetricSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePatchOutput) } +func (i ExternalMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSourcePatch] { + return pulumix.Output[ExternalMetricSourcePatch]{ + OutputState: i.ToExternalMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricSourcePatchArgs) ToExternalMetricSourcePatchPtrOutput() ExternalMetricSourcePatchPtrOutput { return i.ToExternalMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -1321,6 +1496,12 @@ func (i *externalMetricSourcePatchPtrType) ToExternalMetricSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePatchPtrOutput) } +func (i *externalMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSourcePatch] { + return pulumix.Output[*ExternalMetricSourcePatch]{ + OutputState: i.ToExternalMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). type ExternalMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -1346,6 +1527,12 @@ func (o ExternalMetricSourcePatchOutput) ToExternalMetricSourcePatchPtrOutputWit }).(ExternalMetricSourcePatchPtrOutput) } +func (o ExternalMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSourcePatch] { + return pulumix.Output[ExternalMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o ExternalMetricSourcePatchOutput) Metric() MetricIdentifierPatchPtrOutput { return o.ApplyT(func(v ExternalMetricSourcePatch) *MetricIdentifierPatch { return v.Metric }).(MetricIdentifierPatchPtrOutput) @@ -1370,6 +1557,12 @@ func (o ExternalMetricSourcePatchPtrOutput) ToExternalMetricSourcePatchPtrOutput return o } +func (o ExternalMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSourcePatch] { + return pulumix.Output[*ExternalMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricSourcePatchPtrOutput) Elem() ExternalMetricSourcePatchOutput { return o.ApplyT(func(v *ExternalMetricSourcePatch) ExternalMetricSourcePatch { if v != nil { @@ -1439,6 +1632,12 @@ func (i ExternalMetricStatusArgs) ToExternalMetricStatusOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusOutput) } +func (i ExternalMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatus] { + return pulumix.Output[ExternalMetricStatus]{ + OutputState: i.ToExternalMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricStatusArgs) ToExternalMetricStatusPtrOutput() ExternalMetricStatusPtrOutput { return i.ToExternalMetricStatusPtrOutputWithContext(context.Background()) } @@ -1480,6 +1679,12 @@ func (i *externalMetricStatusPtrType) ToExternalMetricStatusPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPtrOutput) } +func (i *externalMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatus] { + return pulumix.Output[*ExternalMetricStatus]{ + OutputState: i.ToExternalMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. type ExternalMetricStatusOutput struct{ *pulumi.OutputState } @@ -1505,6 +1710,12 @@ func (o ExternalMetricStatusOutput) ToExternalMetricStatusPtrOutputWithContext(c }).(ExternalMetricStatusPtrOutput) } +func (o ExternalMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatus] { + return pulumix.Output[ExternalMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ExternalMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v ExternalMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -1529,6 +1740,12 @@ func (o ExternalMetricStatusPtrOutput) ToExternalMetricStatusPtrOutputWithContex return o } +func (o ExternalMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatus] { + return pulumix.Output[*ExternalMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricStatusPtrOutput) Elem() ExternalMetricStatusOutput { return o.ApplyT(func(v *ExternalMetricStatus) ExternalMetricStatus { if v != nil { @@ -1598,6 +1815,12 @@ func (i ExternalMetricStatusPatchArgs) ToExternalMetricStatusPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPatchOutput) } +func (i ExternalMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatusPatch] { + return pulumix.Output[ExternalMetricStatusPatch]{ + OutputState: i.ToExternalMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricStatusPatchArgs) ToExternalMetricStatusPatchPtrOutput() ExternalMetricStatusPatchPtrOutput { return i.ToExternalMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -1639,6 +1862,12 @@ func (i *externalMetricStatusPatchPtrType) ToExternalMetricStatusPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPatchPtrOutput) } +func (i *externalMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatusPatch] { + return pulumix.Output[*ExternalMetricStatusPatch]{ + OutputState: i.ToExternalMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. type ExternalMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -1664,6 +1893,12 @@ func (o ExternalMetricStatusPatchOutput) ToExternalMetricStatusPatchPtrOutputWit }).(ExternalMetricStatusPatchPtrOutput) } +func (o ExternalMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatusPatch] { + return pulumix.Output[ExternalMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ExternalMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v ExternalMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -1688,6 +1923,12 @@ func (o ExternalMetricStatusPatchPtrOutput) ToExternalMetricStatusPatchPtrOutput return o } +func (o ExternalMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatusPatch] { + return pulumix.Output[*ExternalMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricStatusPatchPtrOutput) Elem() ExternalMetricStatusPatchOutput { return o.ApplyT(func(v *ExternalMetricStatusPatch) ExternalMetricStatusPatch { if v != nil { @@ -1761,6 +2002,12 @@ func (i HPAScalingPolicyArgs) ToHPAScalingPolicyOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyOutput) } +func (i HPAScalingPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicy] { + return pulumix.Output[HPAScalingPolicy]{ + OutputState: i.ToHPAScalingPolicyOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicyArrayInput is an input type that accepts HPAScalingPolicyArray and HPAScalingPolicyArrayOutput values. // You can construct a concrete instance of `HPAScalingPolicyArrayInput` via: // @@ -1786,6 +2033,12 @@ func (i HPAScalingPolicyArray) ToHPAScalingPolicyArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyArrayOutput) } +func (i HPAScalingPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicy] { + return pulumix.Output[[]HPAScalingPolicy]{ + OutputState: i.ToHPAScalingPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicy is a single policy which must hold true for a specified past interval. type HPAScalingPolicyOutput struct{ *pulumi.OutputState } @@ -1801,6 +2054,12 @@ func (o HPAScalingPolicyOutput) ToHPAScalingPolicyOutputWithContext(ctx context. return o } +func (o HPAScalingPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicy] { + return pulumix.Output[HPAScalingPolicy]{ + OutputState: o.OutputState, + } +} + // periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). func (o HPAScalingPolicyOutput) PeriodSeconds() pulumi.IntOutput { return o.ApplyT(func(v HPAScalingPolicy) int { return v.PeriodSeconds }).(pulumi.IntOutput) @@ -1830,6 +2089,12 @@ func (o HPAScalingPolicyArrayOutput) ToHPAScalingPolicyArrayOutputWithContext(ct return o } +func (o HPAScalingPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicy] { + return pulumix.Output[[]HPAScalingPolicy]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingPolicyArrayOutput) Index(i pulumi.IntInput) HPAScalingPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HPAScalingPolicy { return vs[0].([]HPAScalingPolicy)[vs[1].(int)] @@ -1879,6 +2144,12 @@ func (i HPAScalingPolicyPatchArgs) ToHPAScalingPolicyPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyPatchOutput) } +func (i HPAScalingPolicyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicyPatch] { + return pulumix.Output[HPAScalingPolicyPatch]{ + OutputState: i.ToHPAScalingPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicyPatchArrayInput is an input type that accepts HPAScalingPolicyPatchArray and HPAScalingPolicyPatchArrayOutput values. // You can construct a concrete instance of `HPAScalingPolicyPatchArrayInput` via: // @@ -1904,6 +2175,12 @@ func (i HPAScalingPolicyPatchArray) ToHPAScalingPolicyPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyPatchArrayOutput) } +func (i HPAScalingPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicyPatch] { + return pulumix.Output[[]HPAScalingPolicyPatch]{ + OutputState: i.ToHPAScalingPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicy is a single policy which must hold true for a specified past interval. type HPAScalingPolicyPatchOutput struct{ *pulumi.OutputState } @@ -1919,6 +2196,12 @@ func (o HPAScalingPolicyPatchOutput) ToHPAScalingPolicyPatchOutputWithContext(ct return o } +func (o HPAScalingPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicyPatch] { + return pulumix.Output[HPAScalingPolicyPatch]{ + OutputState: o.OutputState, + } +} + // periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). func (o HPAScalingPolicyPatchOutput) PeriodSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v HPAScalingPolicyPatch) *int { return v.PeriodSeconds }).(pulumi.IntPtrOutput) @@ -1948,6 +2231,12 @@ func (o HPAScalingPolicyPatchArrayOutput) ToHPAScalingPolicyPatchArrayOutputWith return o } +func (o HPAScalingPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicyPatch] { + return pulumix.Output[[]HPAScalingPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingPolicyPatchArrayOutput) Index(i pulumi.IntInput) HPAScalingPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HPAScalingPolicyPatch { return vs[0].([]HPAScalingPolicyPatch)[vs[1].(int)] @@ -1997,6 +2286,12 @@ func (i HPAScalingRulesArgs) ToHPAScalingRulesOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesOutput) } +func (i HPAScalingRulesArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRules] { + return pulumix.Output[HPAScalingRules]{ + OutputState: i.ToHPAScalingRulesOutputWithContext(ctx).OutputState, + } +} + func (i HPAScalingRulesArgs) ToHPAScalingRulesPtrOutput() HPAScalingRulesPtrOutput { return i.ToHPAScalingRulesPtrOutputWithContext(context.Background()) } @@ -2038,6 +2333,12 @@ func (i *hpascalingRulesPtrType) ToHPAScalingRulesPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesPtrOutput) } +func (i *hpascalingRulesPtrType) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRules] { + return pulumix.Output[*HPAScalingRules]{ + OutputState: i.ToHPAScalingRulesPtrOutputWithContext(ctx).OutputState, + } +} + // HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen. type HPAScalingRulesOutput struct{ *pulumi.OutputState } @@ -2063,6 +2364,12 @@ func (o HPAScalingRulesOutput) ToHPAScalingRulesPtrOutputWithContext(ctx context }).(HPAScalingRulesPtrOutput) } +func (o HPAScalingRulesOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRules] { + return pulumix.Output[HPAScalingRules]{ + OutputState: o.OutputState, + } +} + // policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid func (o HPAScalingRulesOutput) Policies() HPAScalingPolicyArrayOutput { return o.ApplyT(func(v HPAScalingRules) []HPAScalingPolicy { return v.Policies }).(HPAScalingPolicyArrayOutput) @@ -2092,6 +2399,12 @@ func (o HPAScalingRulesPtrOutput) ToHPAScalingRulesPtrOutputWithContext(ctx cont return o } +func (o HPAScalingRulesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRules] { + return pulumix.Output[*HPAScalingRules]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingRulesPtrOutput) Elem() HPAScalingRulesOutput { return o.ApplyT(func(v *HPAScalingRules) HPAScalingRules { if v != nil { @@ -2175,6 +2488,12 @@ func (i HPAScalingRulesPatchArgs) ToHPAScalingRulesPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesPatchOutput) } +func (i HPAScalingRulesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRulesPatch] { + return pulumix.Output[HPAScalingRulesPatch]{ + OutputState: i.ToHPAScalingRulesPatchOutputWithContext(ctx).OutputState, + } +} + func (i HPAScalingRulesPatchArgs) ToHPAScalingRulesPatchPtrOutput() HPAScalingRulesPatchPtrOutput { return i.ToHPAScalingRulesPatchPtrOutputWithContext(context.Background()) } @@ -2216,6 +2535,12 @@ func (i *hpascalingRulesPatchPtrType) ToHPAScalingRulesPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesPatchPtrOutput) } +func (i *hpascalingRulesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRulesPatch] { + return pulumix.Output[*HPAScalingRulesPatch]{ + OutputState: i.ToHPAScalingRulesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen. type HPAScalingRulesPatchOutput struct{ *pulumi.OutputState } @@ -2241,6 +2566,12 @@ func (o HPAScalingRulesPatchOutput) ToHPAScalingRulesPatchPtrOutputWithContext(c }).(HPAScalingRulesPatchPtrOutput) } +func (o HPAScalingRulesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRulesPatch] { + return pulumix.Output[HPAScalingRulesPatch]{ + OutputState: o.OutputState, + } +} + // policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid func (o HPAScalingRulesPatchOutput) Policies() HPAScalingPolicyPatchArrayOutput { return o.ApplyT(func(v HPAScalingRulesPatch) []HPAScalingPolicyPatch { return v.Policies }).(HPAScalingPolicyPatchArrayOutput) @@ -2270,6 +2601,12 @@ func (o HPAScalingRulesPatchPtrOutput) ToHPAScalingRulesPatchPtrOutputWithContex return o } +func (o HPAScalingRulesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRulesPatch] { + return pulumix.Output[*HPAScalingRulesPatch]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingRulesPatchPtrOutput) Elem() HPAScalingRulesPatchOutput { return o.ApplyT(func(v *HPAScalingRulesPatch) HPAScalingRulesPatch { if v != nil { @@ -2361,6 +2698,12 @@ func (i HorizontalPodAutoscalerTypeArgs) ToHorizontalPodAutoscalerTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeOutput) } +func (i HorizontalPodAutoscalerTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerTypeArrayInput is an input type that accepts HorizontalPodAutoscalerTypeArray and HorizontalPodAutoscalerTypeArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerTypeArrayInput` via: // @@ -2386,6 +2729,12 @@ func (i HorizontalPodAutoscalerTypeArray) ToHorizontalPodAutoscalerTypeArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeArrayOutput) } +func (i HorizontalPodAutoscalerTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. type HorizontalPodAutoscalerTypeOutput struct{ *pulumi.OutputState } @@ -2401,6 +2750,12 @@ func (o HorizontalPodAutoscalerTypeOutput) ToHorizontalPodAutoscalerTypeOutputWi return o } +func (o HorizontalPodAutoscalerTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2440,6 +2795,12 @@ func (o HorizontalPodAutoscalerTypeArrayOutput) ToHorizontalPodAutoscalerTypeArr return o } +func (o HorizontalPodAutoscalerTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerTypeArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerType { return vs[0].([]HorizontalPodAutoscalerType)[vs[1].(int)] @@ -2491,6 +2852,12 @@ func (i HorizontalPodAutoscalerBehaviorArgs) ToHorizontalPodAutoscalerBehaviorOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorOutput) } +func (i HorizontalPodAutoscalerBehaviorArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehavior] { + return pulumix.Output[HorizontalPodAutoscalerBehavior]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerBehaviorArgs) ToHorizontalPodAutoscalerBehaviorPtrOutput() HorizontalPodAutoscalerBehaviorPtrOutput { return i.ToHorizontalPodAutoscalerBehaviorPtrOutputWithContext(context.Background()) } @@ -2532,6 +2899,12 @@ func (i *horizontalPodAutoscalerBehaviorPtrType) ToHorizontalPodAutoscalerBehavi return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorPtrOutput) } +func (i *horizontalPodAutoscalerBehaviorPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehavior] { + return pulumix.Output[*HorizontalPodAutoscalerBehavior]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). type HorizontalPodAutoscalerBehaviorOutput struct{ *pulumi.OutputState } @@ -2557,6 +2930,12 @@ func (o HorizontalPodAutoscalerBehaviorOutput) ToHorizontalPodAutoscalerBehavior }).(HorizontalPodAutoscalerBehaviorPtrOutput) } +func (o HorizontalPodAutoscalerBehaviorOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehavior] { + return pulumix.Output[HorizontalPodAutoscalerBehavior]{ + OutputState: o.OutputState, + } +} + // scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used). func (o HorizontalPodAutoscalerBehaviorOutput) ScaleDown() HPAScalingRulesPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerBehavior) *HPAScalingRules { return v.ScaleDown }).(HPAScalingRulesPtrOutput) @@ -2584,6 +2963,12 @@ func (o HorizontalPodAutoscalerBehaviorPtrOutput) ToHorizontalPodAutoscalerBehav return o } +func (o HorizontalPodAutoscalerBehaviorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehavior] { + return pulumix.Output[*HorizontalPodAutoscalerBehavior]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerBehaviorPtrOutput) Elem() HorizontalPodAutoscalerBehaviorOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerBehavior) HorizontalPodAutoscalerBehavior { if v != nil { @@ -2662,6 +3047,12 @@ func (i HorizontalPodAutoscalerBehaviorPatchArgs) ToHorizontalPodAutoscalerBehav return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorPatchOutput) } +func (i HorizontalPodAutoscalerBehaviorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerBehaviorPatchArgs) ToHorizontalPodAutoscalerBehaviorPatchPtrOutput() HorizontalPodAutoscalerBehaviorPatchPtrOutput { return i.ToHorizontalPodAutoscalerBehaviorPatchPtrOutputWithContext(context.Background()) } @@ -2703,6 +3094,12 @@ func (i *horizontalPodAutoscalerBehaviorPatchPtrType) ToHorizontalPodAutoscalerB return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorPatchPtrOutput) } +func (i *horizontalPodAutoscalerBehaviorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). type HorizontalPodAutoscalerBehaviorPatchOutput struct{ *pulumi.OutputState } @@ -2728,6 +3125,12 @@ func (o HorizontalPodAutoscalerBehaviorPatchOutput) ToHorizontalPodAutoscalerBeh }).(HorizontalPodAutoscalerBehaviorPatchPtrOutput) } +func (o HorizontalPodAutoscalerBehaviorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: o.OutputState, + } +} + // scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used). func (o HorizontalPodAutoscalerBehaviorPatchOutput) ScaleDown() HPAScalingRulesPatchPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerBehaviorPatch) *HPAScalingRulesPatch { return v.ScaleDown }).(HPAScalingRulesPatchPtrOutput) @@ -2755,6 +3158,12 @@ func (o HorizontalPodAutoscalerBehaviorPatchPtrOutput) ToHorizontalPodAutoscaler return o } +func (o HorizontalPodAutoscalerBehaviorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerBehaviorPatchPtrOutput) Elem() HorizontalPodAutoscalerBehaviorPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerBehaviorPatch) HorizontalPodAutoscalerBehaviorPatch { if v != nil { @@ -2839,6 +3248,12 @@ func (i HorizontalPodAutoscalerConditionArgs) ToHorizontalPodAutoscalerCondition return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionOutput) } +func (i HorizontalPodAutoscalerConditionArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerCondition] { + return pulumix.Output[HorizontalPodAutoscalerCondition]{ + OutputState: i.ToHorizontalPodAutoscalerConditionOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerConditionArrayInput is an input type that accepts HorizontalPodAutoscalerConditionArray and HorizontalPodAutoscalerConditionArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerConditionArrayInput` via: // @@ -2864,6 +3279,12 @@ func (i HorizontalPodAutoscalerConditionArray) ToHorizontalPodAutoscalerConditio return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionArrayOutput) } +func (i HorizontalPodAutoscalerConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerCondition] { + return pulumix.Output[[]HorizontalPodAutoscalerCondition]{ + OutputState: i.ToHorizontalPodAutoscalerConditionArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. type HorizontalPodAutoscalerConditionOutput struct{ *pulumi.OutputState } @@ -2879,6 +3300,12 @@ func (o HorizontalPodAutoscalerConditionOutput) ToHorizontalPodAutoscalerConditi return o } +func (o HorizontalPodAutoscalerConditionOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerCondition] { + return pulumix.Output[HorizontalPodAutoscalerCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another func (o HorizontalPodAutoscalerConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2918,6 +3345,12 @@ func (o HorizontalPodAutoscalerConditionArrayOutput) ToHorizontalPodAutoscalerCo return o } +func (o HorizontalPodAutoscalerConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerCondition] { + return pulumix.Output[[]HorizontalPodAutoscalerCondition]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerConditionArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerCondition { return vs[0].([]HorizontalPodAutoscalerCondition)[vs[1].(int)] @@ -2975,6 +3408,12 @@ func (i HorizontalPodAutoscalerConditionPatchArgs) ToHorizontalPodAutoscalerCond return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionPatchOutput) } +func (i HorizontalPodAutoscalerConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[HorizontalPodAutoscalerConditionPatch]{ + OutputState: i.ToHorizontalPodAutoscalerConditionPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerConditionPatchArrayInput is an input type that accepts HorizontalPodAutoscalerConditionPatchArray and HorizontalPodAutoscalerConditionPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerConditionPatchArrayInput` via: // @@ -3000,6 +3439,12 @@ func (i HorizontalPodAutoscalerConditionPatchArray) ToHorizontalPodAutoscalerCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionPatchArrayOutput) } +func (i HorizontalPodAutoscalerConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[[]HorizontalPodAutoscalerConditionPatch]{ + OutputState: i.ToHorizontalPodAutoscalerConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. type HorizontalPodAutoscalerConditionPatchOutput struct{ *pulumi.OutputState } @@ -3015,6 +3460,12 @@ func (o HorizontalPodAutoscalerConditionPatchOutput) ToHorizontalPodAutoscalerCo return o } +func (o HorizontalPodAutoscalerConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[HorizontalPodAutoscalerConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another func (o HorizontalPodAutoscalerConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3054,6 +3505,12 @@ func (o HorizontalPodAutoscalerConditionPatchArrayOutput) ToHorizontalPodAutosca return o } +func (o HorizontalPodAutoscalerConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[[]HorizontalPodAutoscalerConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerConditionPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerConditionPatch { return vs[0].([]HorizontalPodAutoscalerConditionPatch)[vs[1].(int)] @@ -3107,6 +3564,12 @@ func (i HorizontalPodAutoscalerListTypeArgs) ToHorizontalPodAutoscalerListTypeOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListTypeOutput) } +func (i HorizontalPodAutoscalerListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: i.ToHorizontalPodAutoscalerListTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. type HorizontalPodAutoscalerListTypeOutput struct{ *pulumi.OutputState } @@ -3122,6 +3585,12 @@ func (o HorizontalPodAutoscalerListTypeOutput) ToHorizontalPodAutoscalerListType return o } +func (o HorizontalPodAutoscalerListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3193,6 +3662,12 @@ func (i HorizontalPodAutoscalerPatchTypeArgs) ToHorizontalPodAutoscalerPatchType return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchTypeOutput) } +func (i HorizontalPodAutoscalerPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: i.ToHorizontalPodAutoscalerPatchTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. type HorizontalPodAutoscalerPatchTypeOutput struct{ *pulumi.OutputState } @@ -3208,6 +3683,12 @@ func (o HorizontalPodAutoscalerPatchTypeOutput) ToHorizontalPodAutoscalerPatchTy return o } +func (o HorizontalPodAutoscalerPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3284,6 +3765,12 @@ func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecOutput) } +func (i HorizontalPodAutoscalerSpecArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecPtrOutput() HorizontalPodAutoscalerSpecPtrOutput { return i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(context.Background()) } @@ -3325,6 +3812,12 @@ func (i *horizontalPodAutoscalerSpecPtrType) ToHorizontalPodAutoscalerSpecPtrOut return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPtrOutput) } +func (i *horizontalPodAutoscalerSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. type HorizontalPodAutoscalerSpecOutput struct{ *pulumi.OutputState } @@ -3350,6 +3843,12 @@ func (o HorizontalPodAutoscalerSpecOutput) ToHorizontalPodAutoscalerSpecPtrOutpu }).(HorizontalPodAutoscalerSpecPtrOutput) } +func (o HorizontalPodAutoscalerSpecOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + // behavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). If not set, the default HPAScalingRules for scale up and scale down are used. func (o HorizontalPodAutoscalerSpecOutput) Behavior() HorizontalPodAutoscalerBehaviorPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpec) *HorizontalPodAutoscalerBehavior { return v.Behavior }).(HorizontalPodAutoscalerBehaviorPtrOutput) @@ -3389,6 +3888,12 @@ func (o HorizontalPodAutoscalerSpecPtrOutput) ToHorizontalPodAutoscalerSpecPtrOu return o } +func (o HorizontalPodAutoscalerSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPtrOutput) Elem() HorizontalPodAutoscalerSpecOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpec) HorizontalPodAutoscalerSpec { if v != nil { @@ -3500,6 +4005,12 @@ func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatch return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchOutput) } +func (i HorizontalPodAutoscalerSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatchPtrOutput() HorizontalPodAutoscalerSpecPatchPtrOutput { return i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(context.Background()) } @@ -3541,6 +4052,12 @@ func (i *horizontalPodAutoscalerSpecPatchPtrType) ToHorizontalPodAutoscalerSpecP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (i *horizontalPodAutoscalerSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. type HorizontalPodAutoscalerSpecPatchOutput struct{ *pulumi.OutputState } @@ -3566,6 +4083,12 @@ func (o HorizontalPodAutoscalerSpecPatchOutput) ToHorizontalPodAutoscalerSpecPat }).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (o HorizontalPodAutoscalerSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + // behavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). If not set, the default HPAScalingRules for scale up and scale down are used. func (o HorizontalPodAutoscalerSpecPatchOutput) Behavior() HorizontalPodAutoscalerBehaviorPatchPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpecPatch) *HorizontalPodAutoscalerBehaviorPatch { return v.Behavior }).(HorizontalPodAutoscalerBehaviorPatchPtrOutput) @@ -3605,6 +4128,12 @@ func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToHorizontalPodAutoscalerSpec return o } +func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPatchPtrOutput) Elem() HorizontalPodAutoscalerSpecPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpecPatch) HorizontalPodAutoscalerSpecPatch { if v != nil { @@ -3720,6 +4249,12 @@ func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusOutput) } +func (i HorizontalPodAutoscalerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusPtrOutput() HorizontalPodAutoscalerStatusPtrOutput { return i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(context.Background()) } @@ -3761,6 +4296,12 @@ func (i *horizontalPodAutoscalerStatusPtrType) ToHorizontalPodAutoscalerStatusPt return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPtrOutput) } +func (i *horizontalPodAutoscalerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. type HorizontalPodAutoscalerStatusOutput struct{ *pulumi.OutputState } @@ -3786,6 +4327,12 @@ func (o HorizontalPodAutoscalerStatusOutput) ToHorizontalPodAutoscalerStatusPtrO }).(HorizontalPodAutoscalerStatusPtrOutput) } +func (o HorizontalPodAutoscalerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + // conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. func (o HorizontalPodAutoscalerStatusOutput) Conditions() HorizontalPodAutoscalerConditionArrayOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatus) []HorizontalPodAutoscalerCondition { return v.Conditions }).(HorizontalPodAutoscalerConditionArrayOutput) @@ -3830,6 +4377,12 @@ func (o HorizontalPodAutoscalerStatusPtrOutput) ToHorizontalPodAutoscalerStatusP return o } +func (o HorizontalPodAutoscalerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPtrOutput) Elem() HorizontalPodAutoscalerStatusOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatus) HorizontalPodAutoscalerStatus { if v != nil { @@ -3955,6 +4508,12 @@ func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchOutput) } +func (i HorizontalPodAutoscalerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusPatchPtrOutput() HorizontalPodAutoscalerStatusPatchPtrOutput { return i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(context.Background()) } @@ -3996,6 +4555,12 @@ func (i *horizontalPodAutoscalerStatusPatchPtrType) ToHorizontalPodAutoscalerSta return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (i *horizontalPodAutoscalerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. type HorizontalPodAutoscalerStatusPatchOutput struct{ *pulumi.OutputState } @@ -4021,6 +4586,12 @@ func (o HorizontalPodAutoscalerStatusPatchOutput) ToHorizontalPodAutoscalerStatu }).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (o HorizontalPodAutoscalerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + // conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. func (o HorizontalPodAutoscalerStatusPatchOutput) Conditions() HorizontalPodAutoscalerConditionPatchArrayOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatusPatch) []HorizontalPodAutoscalerConditionPatch { @@ -4067,6 +4638,12 @@ func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToHorizontalPodAutoscalerSt return o } +func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPatchPtrOutput) Elem() HorizontalPodAutoscalerStatusPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatusPatch) HorizontalPodAutoscalerStatusPatch { if v != nil { @@ -4176,6 +4753,12 @@ func (i MetricIdentifierArgs) ToMetricIdentifierOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierOutput) } +func (i MetricIdentifierArgs) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifier] { + return pulumix.Output[MetricIdentifier]{ + OutputState: i.ToMetricIdentifierOutputWithContext(ctx).OutputState, + } +} + func (i MetricIdentifierArgs) ToMetricIdentifierPtrOutput() MetricIdentifierPtrOutput { return i.ToMetricIdentifierPtrOutputWithContext(context.Background()) } @@ -4217,6 +4800,12 @@ func (i *metricIdentifierPtrType) ToMetricIdentifierPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierPtrOutput) } +func (i *metricIdentifierPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifier] { + return pulumix.Output[*MetricIdentifier]{ + OutputState: i.ToMetricIdentifierPtrOutputWithContext(ctx).OutputState, + } +} + // MetricIdentifier defines the name and optionally selector for a metric type MetricIdentifierOutput struct{ *pulumi.OutputState } @@ -4242,6 +4831,12 @@ func (o MetricIdentifierOutput) ToMetricIdentifierPtrOutputWithContext(ctx conte }).(MetricIdentifierPtrOutput) } +func (o MetricIdentifierOutput) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifier] { + return pulumix.Output[MetricIdentifier]{ + OutputState: o.OutputState, + } +} + // name is the name of the given metric func (o MetricIdentifierOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v MetricIdentifier) string { return v.Name }).(pulumi.StringOutput) @@ -4266,6 +4861,12 @@ func (o MetricIdentifierPtrOutput) ToMetricIdentifierPtrOutputWithContext(ctx co return o } +func (o MetricIdentifierPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifier] { + return pulumix.Output[*MetricIdentifier]{ + OutputState: o.OutputState, + } +} + func (o MetricIdentifierPtrOutput) Elem() MetricIdentifierOutput { return o.ApplyT(func(v *MetricIdentifier) MetricIdentifier { if v != nil { @@ -4335,6 +4936,12 @@ func (i MetricIdentifierPatchArgs) ToMetricIdentifierPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierPatchOutput) } +func (i MetricIdentifierPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifierPatch] { + return pulumix.Output[MetricIdentifierPatch]{ + OutputState: i.ToMetricIdentifierPatchOutputWithContext(ctx).OutputState, + } +} + func (i MetricIdentifierPatchArgs) ToMetricIdentifierPatchPtrOutput() MetricIdentifierPatchPtrOutput { return i.ToMetricIdentifierPatchPtrOutputWithContext(context.Background()) } @@ -4376,6 +4983,12 @@ func (i *metricIdentifierPatchPtrType) ToMetricIdentifierPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierPatchPtrOutput) } +func (i *metricIdentifierPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifierPatch] { + return pulumix.Output[*MetricIdentifierPatch]{ + OutputState: i.ToMetricIdentifierPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MetricIdentifier defines the name and optionally selector for a metric type MetricIdentifierPatchOutput struct{ *pulumi.OutputState } @@ -4401,6 +5014,12 @@ func (o MetricIdentifierPatchOutput) ToMetricIdentifierPatchPtrOutputWithContext }).(MetricIdentifierPatchPtrOutput) } +func (o MetricIdentifierPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifierPatch] { + return pulumix.Output[MetricIdentifierPatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the given metric func (o MetricIdentifierPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v MetricIdentifierPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -4425,6 +5044,12 @@ func (o MetricIdentifierPatchPtrOutput) ToMetricIdentifierPatchPtrOutputWithCont return o } +func (o MetricIdentifierPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifierPatch] { + return pulumix.Output[*MetricIdentifierPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricIdentifierPatchPtrOutput) Elem() MetricIdentifierPatchOutput { return o.ApplyT(func(v *MetricIdentifierPatch) MetricIdentifierPatch { if v != nil { @@ -4510,6 +5135,12 @@ func (i MetricSpecArgs) ToMetricSpecOutputWithContext(ctx context.Context) Metri return pulumi.ToOutputWithContext(ctx, i).(MetricSpecOutput) } +func (i MetricSpecArgs) ToOutput(ctx context.Context) pulumix.Output[MetricSpec] { + return pulumix.Output[MetricSpec]{ + OutputState: i.ToMetricSpecOutputWithContext(ctx).OutputState, + } +} + // MetricSpecArrayInput is an input type that accepts MetricSpecArray and MetricSpecArrayOutput values. // You can construct a concrete instance of `MetricSpecArrayInput` via: // @@ -4535,6 +5166,12 @@ func (i MetricSpecArray) ToMetricSpecArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(MetricSpecArrayOutput) } +func (i MetricSpecArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpec] { + return pulumix.Output[[]MetricSpec]{ + OutputState: i.ToMetricSpecArrayOutputWithContext(ctx).OutputState, + } +} + // MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). type MetricSpecOutput struct{ *pulumi.OutputState } @@ -4550,6 +5187,12 @@ func (o MetricSpecOutput) ToMetricSpecOutputWithContext(ctx context.Context) Met return o } +func (o MetricSpecOutput) ToOutput(ctx context.Context) pulumix.Output[MetricSpec] { + return pulumix.Output[MetricSpec]{ + OutputState: o.OutputState, + } +} + // containerResource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. func (o MetricSpecOutput) ContainerResource() ContainerResourceMetricSourcePtrOutput { return o.ApplyT(func(v MetricSpec) *ContainerResourceMetricSource { return v.ContainerResource }).(ContainerResourceMetricSourcePtrOutput) @@ -4594,6 +5237,12 @@ func (o MetricSpecArrayOutput) ToMetricSpecArrayOutputWithContext(ctx context.Co return o } +func (o MetricSpecArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpec] { + return pulumix.Output[[]MetricSpec]{ + OutputState: o.OutputState, + } +} + func (o MetricSpecArrayOutput) Index(i pulumi.IntInput) MetricSpecOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricSpec { return vs[0].([]MetricSpec)[vs[1].(int)] @@ -4655,6 +5304,12 @@ func (i MetricSpecPatchArgs) ToMetricSpecPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MetricSpecPatchOutput) } +func (i MetricSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricSpecPatch] { + return pulumix.Output[MetricSpecPatch]{ + OutputState: i.ToMetricSpecPatchOutputWithContext(ctx).OutputState, + } +} + // MetricSpecPatchArrayInput is an input type that accepts MetricSpecPatchArray and MetricSpecPatchArrayOutput values. // You can construct a concrete instance of `MetricSpecPatchArrayInput` via: // @@ -4680,6 +5335,12 @@ func (i MetricSpecPatchArray) ToMetricSpecPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(MetricSpecPatchArrayOutput) } +func (i MetricSpecPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpecPatch] { + return pulumix.Output[[]MetricSpecPatch]{ + OutputState: i.ToMetricSpecPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). type MetricSpecPatchOutput struct{ *pulumi.OutputState } @@ -4695,6 +5356,12 @@ func (o MetricSpecPatchOutput) ToMetricSpecPatchOutputWithContext(ctx context.Co return o } +func (o MetricSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricSpecPatch] { + return pulumix.Output[MetricSpecPatch]{ + OutputState: o.OutputState, + } +} + // containerResource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. func (o MetricSpecPatchOutput) ContainerResource() ContainerResourceMetricSourcePatchPtrOutput { return o.ApplyT(func(v MetricSpecPatch) *ContainerResourceMetricSourcePatch { return v.ContainerResource }).(ContainerResourceMetricSourcePatchPtrOutput) @@ -4739,6 +5406,12 @@ func (o MetricSpecPatchArrayOutput) ToMetricSpecPatchArrayOutputWithContext(ctx return o } +func (o MetricSpecPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpecPatch] { + return pulumix.Output[[]MetricSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricSpecPatchArrayOutput) Index(i pulumi.IntInput) MetricSpecPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricSpecPatch { return vs[0].([]MetricSpecPatch)[vs[1].(int)] @@ -4800,6 +5473,12 @@ func (i MetricStatusArgs) ToMetricStatusOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(MetricStatusOutput) } +func (i MetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[MetricStatus] { + return pulumix.Output[MetricStatus]{ + OutputState: i.ToMetricStatusOutputWithContext(ctx).OutputState, + } +} + // MetricStatusArrayInput is an input type that accepts MetricStatusArray and MetricStatusArrayOutput values. // You can construct a concrete instance of `MetricStatusArrayInput` via: // @@ -4825,6 +5504,12 @@ func (i MetricStatusArray) ToMetricStatusArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MetricStatusArrayOutput) } +func (i MetricStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatus] { + return pulumix.Output[[]MetricStatus]{ + OutputState: i.ToMetricStatusArrayOutputWithContext(ctx).OutputState, + } +} + // MetricStatus describes the last-read state of a single metric. type MetricStatusOutput struct{ *pulumi.OutputState } @@ -4840,6 +5525,12 @@ func (o MetricStatusOutput) ToMetricStatusOutputWithContext(ctx context.Context) return o } +func (o MetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[MetricStatus] { + return pulumix.Output[MetricStatus]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. func (o MetricStatusOutput) ContainerResource() ContainerResourceMetricStatusPtrOutput { return o.ApplyT(func(v MetricStatus) *ContainerResourceMetricStatus { return v.ContainerResource }).(ContainerResourceMetricStatusPtrOutput) @@ -4884,6 +5575,12 @@ func (o MetricStatusArrayOutput) ToMetricStatusArrayOutputWithContext(ctx contex return o } +func (o MetricStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatus] { + return pulumix.Output[[]MetricStatus]{ + OutputState: o.OutputState, + } +} + func (o MetricStatusArrayOutput) Index(i pulumi.IntInput) MetricStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricStatus { return vs[0].([]MetricStatus)[vs[1].(int)] @@ -4945,6 +5642,12 @@ func (i MetricStatusPatchArgs) ToMetricStatusPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricStatusPatchOutput) } +func (i MetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricStatusPatch] { + return pulumix.Output[MetricStatusPatch]{ + OutputState: i.ToMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + // MetricStatusPatchArrayInput is an input type that accepts MetricStatusPatchArray and MetricStatusPatchArrayOutput values. // You can construct a concrete instance of `MetricStatusPatchArrayInput` via: // @@ -4970,6 +5673,12 @@ func (i MetricStatusPatchArray) ToMetricStatusPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(MetricStatusPatchArrayOutput) } +func (i MetricStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatusPatch] { + return pulumix.Output[[]MetricStatusPatch]{ + OutputState: i.ToMetricStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MetricStatus describes the last-read state of a single metric. type MetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -4985,6 +5694,12 @@ func (o MetricStatusPatchOutput) ToMetricStatusPatchOutputWithContext(ctx contex return o } +func (o MetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricStatusPatch] { + return pulumix.Output[MetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. func (o MetricStatusPatchOutput) ContainerResource() ContainerResourceMetricStatusPatchPtrOutput { return o.ApplyT(func(v MetricStatusPatch) *ContainerResourceMetricStatusPatch { return v.ContainerResource }).(ContainerResourceMetricStatusPatchPtrOutput) @@ -5029,6 +5744,12 @@ func (o MetricStatusPatchArrayOutput) ToMetricStatusPatchArrayOutputWithContext( return o } +func (o MetricStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatusPatch] { + return pulumix.Output[[]MetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricStatusPatchArrayOutput) Index(i pulumi.IntInput) MetricStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricStatusPatch { return vs[0].([]MetricStatusPatch)[vs[1].(int)] @@ -5082,6 +5803,12 @@ func (i MetricTargetArgs) ToMetricTargetOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(MetricTargetOutput) } +func (i MetricTargetArgs) ToOutput(ctx context.Context) pulumix.Output[MetricTarget] { + return pulumix.Output[MetricTarget]{ + OutputState: i.ToMetricTargetOutputWithContext(ctx).OutputState, + } +} + func (i MetricTargetArgs) ToMetricTargetPtrOutput() MetricTargetPtrOutput { return i.ToMetricTargetPtrOutputWithContext(context.Background()) } @@ -5123,6 +5850,12 @@ func (i *metricTargetPtrType) ToMetricTargetPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(MetricTargetPtrOutput) } +func (i *metricTargetPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricTarget] { + return pulumix.Output[*MetricTarget]{ + OutputState: i.ToMetricTargetPtrOutputWithContext(ctx).OutputState, + } +} + // MetricTarget defines the target value, average value, or average utilization of a specific metric type MetricTargetOutput struct{ *pulumi.OutputState } @@ -5148,6 +5881,12 @@ func (o MetricTargetOutput) ToMetricTargetPtrOutputWithContext(ctx context.Conte }).(MetricTargetPtrOutput) } +func (o MetricTargetOutput) ToOutput(ctx context.Context) pulumix.Output[MetricTarget] { + return pulumix.Output[MetricTarget]{ + OutputState: o.OutputState, + } +} + // averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type func (o MetricTargetOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricTarget) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5182,6 +5921,12 @@ func (o MetricTargetPtrOutput) ToMetricTargetPtrOutputWithContext(ctx context.Co return o } +func (o MetricTargetPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricTarget] { + return pulumix.Output[*MetricTarget]{ + OutputState: o.OutputState, + } +} + func (o MetricTargetPtrOutput) Elem() MetricTargetOutput { return o.ApplyT(func(v *MetricTarget) MetricTarget { if v != nil { @@ -5279,6 +6024,12 @@ func (i MetricTargetPatchArgs) ToMetricTargetPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricTargetPatchOutput) } +func (i MetricTargetPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricTargetPatch] { + return pulumix.Output[MetricTargetPatch]{ + OutputState: i.ToMetricTargetPatchOutputWithContext(ctx).OutputState, + } +} + func (i MetricTargetPatchArgs) ToMetricTargetPatchPtrOutput() MetricTargetPatchPtrOutput { return i.ToMetricTargetPatchPtrOutputWithContext(context.Background()) } @@ -5320,6 +6071,12 @@ func (i *metricTargetPatchPtrType) ToMetricTargetPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(MetricTargetPatchPtrOutput) } +func (i *metricTargetPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricTargetPatch] { + return pulumix.Output[*MetricTargetPatch]{ + OutputState: i.ToMetricTargetPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MetricTarget defines the target value, average value, or average utilization of a specific metric type MetricTargetPatchOutput struct{ *pulumi.OutputState } @@ -5345,6 +6102,12 @@ func (o MetricTargetPatchOutput) ToMetricTargetPatchPtrOutputWithContext(ctx con }).(MetricTargetPatchPtrOutput) } +func (o MetricTargetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricTargetPatch] { + return pulumix.Output[MetricTargetPatch]{ + OutputState: o.OutputState, + } +} + // averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type func (o MetricTargetPatchOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricTargetPatch) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5379,6 +6142,12 @@ func (o MetricTargetPatchPtrOutput) ToMetricTargetPatchPtrOutputWithContext(ctx return o } +func (o MetricTargetPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricTargetPatch] { + return pulumix.Output[*MetricTargetPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricTargetPatchPtrOutput) Elem() MetricTargetPatchOutput { return o.ApplyT(func(v *MetricTargetPatch) MetricTargetPatch { if v != nil { @@ -5472,6 +6241,12 @@ func (i MetricValueStatusArgs) ToMetricValueStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusOutput) } +func (i MetricValueStatusArgs) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatus] { + return pulumix.Output[MetricValueStatus]{ + OutputState: i.ToMetricValueStatusOutputWithContext(ctx).OutputState, + } +} + func (i MetricValueStatusArgs) ToMetricValueStatusPtrOutput() MetricValueStatusPtrOutput { return i.ToMetricValueStatusPtrOutputWithContext(context.Background()) } @@ -5513,6 +6288,12 @@ func (i *metricValueStatusPtrType) ToMetricValueStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusPtrOutput) } +func (i *metricValueStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatus] { + return pulumix.Output[*MetricValueStatus]{ + OutputState: i.ToMetricValueStatusPtrOutputWithContext(ctx).OutputState, + } +} + // MetricValueStatus holds the current value for a metric type MetricValueStatusOutput struct{ *pulumi.OutputState } @@ -5538,6 +6319,12 @@ func (o MetricValueStatusOutput) ToMetricValueStatusPtrOutputWithContext(ctx con }).(MetricValueStatusPtrOutput) } +func (o MetricValueStatusOutput) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatus] { + return pulumix.Output[MetricValueStatus]{ + OutputState: o.OutputState, + } +} + // currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. func (o MetricValueStatusOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricValueStatus) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5567,6 +6354,12 @@ func (o MetricValueStatusPtrOutput) ToMetricValueStatusPtrOutputWithContext(ctx return o } +func (o MetricValueStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatus] { + return pulumix.Output[*MetricValueStatus]{ + OutputState: o.OutputState, + } +} + func (o MetricValueStatusPtrOutput) Elem() MetricValueStatusOutput { return o.ApplyT(func(v *MetricValueStatus) MetricValueStatus { if v != nil { @@ -5650,6 +6443,12 @@ func (i MetricValueStatusPatchArgs) ToMetricValueStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusPatchOutput) } +func (i MetricValueStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatusPatch] { + return pulumix.Output[MetricValueStatusPatch]{ + OutputState: i.ToMetricValueStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i MetricValueStatusPatchArgs) ToMetricValueStatusPatchPtrOutput() MetricValueStatusPatchPtrOutput { return i.ToMetricValueStatusPatchPtrOutputWithContext(context.Background()) } @@ -5691,6 +6490,12 @@ func (i *metricValueStatusPatchPtrType) ToMetricValueStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusPatchPtrOutput) } +func (i *metricValueStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatusPatch] { + return pulumix.Output[*MetricValueStatusPatch]{ + OutputState: i.ToMetricValueStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MetricValueStatus holds the current value for a metric type MetricValueStatusPatchOutput struct{ *pulumi.OutputState } @@ -5716,6 +6521,12 @@ func (o MetricValueStatusPatchOutput) ToMetricValueStatusPatchPtrOutputWithConte }).(MetricValueStatusPatchPtrOutput) } +func (o MetricValueStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatusPatch] { + return pulumix.Output[MetricValueStatusPatch]{ + OutputState: o.OutputState, + } +} + // currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. func (o MetricValueStatusPatchOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricValueStatusPatch) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5745,6 +6556,12 @@ func (o MetricValueStatusPatchPtrOutput) ToMetricValueStatusPatchPtrOutputWithCo return o } +func (o MetricValueStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatusPatch] { + return pulumix.Output[*MetricValueStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricValueStatusPatchPtrOutput) Elem() MetricValueStatusPatchOutput { return o.ApplyT(func(v *MetricValueStatusPatch) MetricValueStatusPatch { if v != nil { @@ -5828,6 +6645,12 @@ func (i ObjectMetricSourceArgs) ToObjectMetricSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourceOutput) } +func (i ObjectMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSource] { + return pulumix.Output[ObjectMetricSource]{ + OutputState: i.ToObjectMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricSourceArgs) ToObjectMetricSourcePtrOutput() ObjectMetricSourcePtrOutput { return i.ToObjectMetricSourcePtrOutputWithContext(context.Background()) } @@ -5869,6 +6692,12 @@ func (i *objectMetricSourcePtrType) ToObjectMetricSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePtrOutput) } +func (i *objectMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSource] { + return pulumix.Output[*ObjectMetricSource]{ + OutputState: i.ToObjectMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricSourceOutput struct{ *pulumi.OutputState } @@ -5894,6 +6723,12 @@ func (o ObjectMetricSourceOutput) ToObjectMetricSourcePtrOutputWithContext(ctx c }).(ObjectMetricSourcePtrOutput) } +func (o ObjectMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSource] { + return pulumix.Output[ObjectMetricSource]{ + OutputState: o.OutputState, + } +} + // describedObject specifies the descriptions of a object,such as kind,name apiVersion func (o ObjectMetricSourceOutput) DescribedObject() CrossVersionObjectReferenceOutput { return o.ApplyT(func(v ObjectMetricSource) CrossVersionObjectReference { return v.DescribedObject }).(CrossVersionObjectReferenceOutput) @@ -5923,6 +6758,12 @@ func (o ObjectMetricSourcePtrOutput) ToObjectMetricSourcePtrOutputWithContext(ct return o } +func (o ObjectMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSource] { + return pulumix.Output[*ObjectMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePtrOutput) Elem() ObjectMetricSourceOutput { return o.ApplyT(func(v *ObjectMetricSource) ObjectMetricSource { if v != nil { @@ -6006,6 +6847,12 @@ func (i ObjectMetricSourcePatchArgs) ToObjectMetricSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePatchOutput) } +func (i ObjectMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSourcePatch] { + return pulumix.Output[ObjectMetricSourcePatch]{ + OutputState: i.ToObjectMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricSourcePatchArgs) ToObjectMetricSourcePatchPtrOutput() ObjectMetricSourcePatchPtrOutput { return i.ToObjectMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -6047,6 +6894,12 @@ func (i *objectMetricSourcePatchPtrType) ToObjectMetricSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePatchPtrOutput) } +func (i *objectMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSourcePatch] { + return pulumix.Output[*ObjectMetricSourcePatch]{ + OutputState: i.ToObjectMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -6072,6 +6925,12 @@ func (o ObjectMetricSourcePatchOutput) ToObjectMetricSourcePatchPtrOutputWithCon }).(ObjectMetricSourcePatchPtrOutput) } +func (o ObjectMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSourcePatch] { + return pulumix.Output[ObjectMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // describedObject specifies the descriptions of a object,such as kind,name apiVersion func (o ObjectMetricSourcePatchOutput) DescribedObject() CrossVersionObjectReferencePatchPtrOutput { return o.ApplyT(func(v ObjectMetricSourcePatch) *CrossVersionObjectReferencePatch { return v.DescribedObject }).(CrossVersionObjectReferencePatchPtrOutput) @@ -6101,6 +6960,12 @@ func (o ObjectMetricSourcePatchPtrOutput) ToObjectMetricSourcePatchPtrOutputWith return o } +func (o ObjectMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSourcePatch] { + return pulumix.Output[*ObjectMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePatchPtrOutput) Elem() ObjectMetricSourcePatchOutput { return o.ApplyT(func(v *ObjectMetricSourcePatch) ObjectMetricSourcePatch { if v != nil { @@ -6184,6 +7049,12 @@ func (i ObjectMetricStatusArgs) ToObjectMetricStatusOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusOutput) } +func (i ObjectMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatus] { + return pulumix.Output[ObjectMetricStatus]{ + OutputState: i.ToObjectMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricStatusArgs) ToObjectMetricStatusPtrOutput() ObjectMetricStatusPtrOutput { return i.ToObjectMetricStatusPtrOutputWithContext(context.Background()) } @@ -6225,6 +7096,12 @@ func (i *objectMetricStatusPtrType) ToObjectMetricStatusPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPtrOutput) } +func (i *objectMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatus] { + return pulumix.Output[*ObjectMetricStatus]{ + OutputState: i.ToObjectMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricStatusOutput struct{ *pulumi.OutputState } @@ -6250,6 +7127,12 @@ func (o ObjectMetricStatusOutput) ToObjectMetricStatusPtrOutputWithContext(ctx c }).(ObjectMetricStatusPtrOutput) } +func (o ObjectMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatus] { + return pulumix.Output[ObjectMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ObjectMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v ObjectMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -6279,6 +7162,12 @@ func (o ObjectMetricStatusPtrOutput) ToObjectMetricStatusPtrOutputWithContext(ct return o } +func (o ObjectMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatus] { + return pulumix.Output[*ObjectMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricStatusPtrOutput) Elem() ObjectMetricStatusOutput { return o.ApplyT(func(v *ObjectMetricStatus) ObjectMetricStatus { if v != nil { @@ -6362,6 +7251,12 @@ func (i ObjectMetricStatusPatchArgs) ToObjectMetricStatusPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPatchOutput) } +func (i ObjectMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatusPatch] { + return pulumix.Output[ObjectMetricStatusPatch]{ + OutputState: i.ToObjectMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricStatusPatchArgs) ToObjectMetricStatusPatchPtrOutput() ObjectMetricStatusPatchPtrOutput { return i.ToObjectMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -6403,6 +7298,12 @@ func (i *objectMetricStatusPatchPtrType) ToObjectMetricStatusPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPatchPtrOutput) } +func (i *objectMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatusPatch] { + return pulumix.Output[*ObjectMetricStatusPatch]{ + OutputState: i.ToObjectMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -6428,6 +7329,12 @@ func (o ObjectMetricStatusPatchOutput) ToObjectMetricStatusPatchPtrOutputWithCon }).(ObjectMetricStatusPatchPtrOutput) } +func (o ObjectMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatusPatch] { + return pulumix.Output[ObjectMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ObjectMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v ObjectMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -6457,6 +7364,12 @@ func (o ObjectMetricStatusPatchPtrOutput) ToObjectMetricStatusPatchPtrOutputWith return o } +func (o ObjectMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatusPatch] { + return pulumix.Output[*ObjectMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricStatusPatchPtrOutput) Elem() ObjectMetricStatusPatchOutput { return o.ApplyT(func(v *ObjectMetricStatusPatch) ObjectMetricStatusPatch { if v != nil { @@ -6536,6 +7449,12 @@ func (i PodsMetricSourceArgs) ToPodsMetricSourceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourceOutput) } +func (i PodsMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSource] { + return pulumix.Output[PodsMetricSource]{ + OutputState: i.ToPodsMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricSourceArgs) ToPodsMetricSourcePtrOutput() PodsMetricSourcePtrOutput { return i.ToPodsMetricSourcePtrOutputWithContext(context.Background()) } @@ -6577,6 +7496,12 @@ func (i *podsMetricSourcePtrType) ToPodsMetricSourcePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePtrOutput) } +func (i *podsMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSource] { + return pulumix.Output[*PodsMetricSource]{ + OutputState: i.ToPodsMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. type PodsMetricSourceOutput struct{ *pulumi.OutputState } @@ -6602,6 +7527,12 @@ func (o PodsMetricSourceOutput) ToPodsMetricSourcePtrOutputWithContext(ctx conte }).(PodsMetricSourcePtrOutput) } +func (o PodsMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSource] { + return pulumix.Output[PodsMetricSource]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o PodsMetricSourceOutput) Metric() MetricIdentifierOutput { return o.ApplyT(func(v PodsMetricSource) MetricIdentifier { return v.Metric }).(MetricIdentifierOutput) @@ -6626,6 +7557,12 @@ func (o PodsMetricSourcePtrOutput) ToPodsMetricSourcePtrOutputWithContext(ctx co return o } +func (o PodsMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSource] { + return pulumix.Output[*PodsMetricSource]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricSourcePtrOutput) Elem() PodsMetricSourceOutput { return o.ApplyT(func(v *PodsMetricSource) PodsMetricSource { if v != nil { @@ -6695,6 +7632,12 @@ func (i PodsMetricSourcePatchArgs) ToPodsMetricSourcePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePatchOutput) } +func (i PodsMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSourcePatch] { + return pulumix.Output[PodsMetricSourcePatch]{ + OutputState: i.ToPodsMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricSourcePatchArgs) ToPodsMetricSourcePatchPtrOutput() PodsMetricSourcePatchPtrOutput { return i.ToPodsMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -6736,6 +7679,12 @@ func (i *podsMetricSourcePatchPtrType) ToPodsMetricSourcePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePatchPtrOutput) } +func (i *podsMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSourcePatch] { + return pulumix.Output[*PodsMetricSourcePatch]{ + OutputState: i.ToPodsMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. type PodsMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -6761,6 +7710,12 @@ func (o PodsMetricSourcePatchOutput) ToPodsMetricSourcePatchPtrOutputWithContext }).(PodsMetricSourcePatchPtrOutput) } +func (o PodsMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSourcePatch] { + return pulumix.Output[PodsMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o PodsMetricSourcePatchOutput) Metric() MetricIdentifierPatchPtrOutput { return o.ApplyT(func(v PodsMetricSourcePatch) *MetricIdentifierPatch { return v.Metric }).(MetricIdentifierPatchPtrOutput) @@ -6785,6 +7740,12 @@ func (o PodsMetricSourcePatchPtrOutput) ToPodsMetricSourcePatchPtrOutputWithCont return o } +func (o PodsMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSourcePatch] { + return pulumix.Output[*PodsMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricSourcePatchPtrOutput) Elem() PodsMetricSourcePatchOutput { return o.ApplyT(func(v *PodsMetricSourcePatch) PodsMetricSourcePatch { if v != nil { @@ -6854,6 +7815,12 @@ func (i PodsMetricStatusArgs) ToPodsMetricStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusOutput) } +func (i PodsMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatus] { + return pulumix.Output[PodsMetricStatus]{ + OutputState: i.ToPodsMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricStatusArgs) ToPodsMetricStatusPtrOutput() PodsMetricStatusPtrOutput { return i.ToPodsMetricStatusPtrOutputWithContext(context.Background()) } @@ -6895,6 +7862,12 @@ func (i *podsMetricStatusPtrType) ToPodsMetricStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPtrOutput) } +func (i *podsMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatus] { + return pulumix.Output[*PodsMetricStatus]{ + OutputState: i.ToPodsMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). type PodsMetricStatusOutput struct{ *pulumi.OutputState } @@ -6920,6 +7893,12 @@ func (o PodsMetricStatusOutput) ToPodsMetricStatusPtrOutputWithContext(ctx conte }).(PodsMetricStatusPtrOutput) } +func (o PodsMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatus] { + return pulumix.Output[PodsMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o PodsMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v PodsMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -6944,6 +7923,12 @@ func (o PodsMetricStatusPtrOutput) ToPodsMetricStatusPtrOutputWithContext(ctx co return o } +func (o PodsMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatus] { + return pulumix.Output[*PodsMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricStatusPtrOutput) Elem() PodsMetricStatusOutput { return o.ApplyT(func(v *PodsMetricStatus) PodsMetricStatus { if v != nil { @@ -7013,6 +7998,12 @@ func (i PodsMetricStatusPatchArgs) ToPodsMetricStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPatchOutput) } +func (i PodsMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatusPatch] { + return pulumix.Output[PodsMetricStatusPatch]{ + OutputState: i.ToPodsMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricStatusPatchArgs) ToPodsMetricStatusPatchPtrOutput() PodsMetricStatusPatchPtrOutput { return i.ToPodsMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -7054,6 +8045,12 @@ func (i *podsMetricStatusPatchPtrType) ToPodsMetricStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPatchPtrOutput) } +func (i *podsMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatusPatch] { + return pulumix.Output[*PodsMetricStatusPatch]{ + OutputState: i.ToPodsMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). type PodsMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -7079,6 +8076,12 @@ func (o PodsMetricStatusPatchOutput) ToPodsMetricStatusPatchPtrOutputWithContext }).(PodsMetricStatusPatchPtrOutput) } +func (o PodsMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatusPatch] { + return pulumix.Output[PodsMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o PodsMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v PodsMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -7103,6 +8106,12 @@ func (o PodsMetricStatusPatchPtrOutput) ToPodsMetricStatusPatchPtrOutputWithCont return o } +func (o PodsMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatusPatch] { + return pulumix.Output[*PodsMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricStatusPatchPtrOutput) Elem() PodsMetricStatusPatchOutput { return o.ApplyT(func(v *PodsMetricStatusPatch) PodsMetricStatusPatch { if v != nil { @@ -7172,6 +8181,12 @@ func (i ResourceMetricSourceArgs) ToResourceMetricSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourceOutput) } +func (i ResourceMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSource] { + return pulumix.Output[ResourceMetricSource]{ + OutputState: i.ToResourceMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricSourceArgs) ToResourceMetricSourcePtrOutput() ResourceMetricSourcePtrOutput { return i.ToResourceMetricSourcePtrOutputWithContext(context.Background()) } @@ -7213,6 +8228,12 @@ func (i *resourceMetricSourcePtrType) ToResourceMetricSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePtrOutput) } +func (i *resourceMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSource] { + return pulumix.Output[*ResourceMetricSource]{ + OutputState: i.ToResourceMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ResourceMetricSourceOutput struct{ *pulumi.OutputState } @@ -7238,6 +8259,12 @@ func (o ResourceMetricSourceOutput) ToResourceMetricSourcePtrOutputWithContext(c }).(ResourceMetricSourcePtrOutput) } +func (o ResourceMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSource] { + return pulumix.Output[ResourceMetricSource]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource in question. func (o ResourceMetricSourceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ResourceMetricSource) string { return v.Name }).(pulumi.StringOutput) @@ -7262,6 +8289,12 @@ func (o ResourceMetricSourcePtrOutput) ToResourceMetricSourcePtrOutputWithContex return o } +func (o ResourceMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSource] { + return pulumix.Output[*ResourceMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricSourcePtrOutput) Elem() ResourceMetricSourceOutput { return o.ApplyT(func(v *ResourceMetricSource) ResourceMetricSource { if v != nil { @@ -7331,6 +8364,12 @@ func (i ResourceMetricSourcePatchArgs) ToResourceMetricSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePatchOutput) } +func (i ResourceMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSourcePatch] { + return pulumix.Output[ResourceMetricSourcePatch]{ + OutputState: i.ToResourceMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricSourcePatchArgs) ToResourceMetricSourcePatchPtrOutput() ResourceMetricSourcePatchPtrOutput { return i.ToResourceMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -7372,6 +8411,12 @@ func (i *resourceMetricSourcePatchPtrType) ToResourceMetricSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePatchPtrOutput) } +func (i *resourceMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSourcePatch] { + return pulumix.Output[*ResourceMetricSourcePatch]{ + OutputState: i.ToResourceMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ResourceMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -7397,6 +8442,12 @@ func (o ResourceMetricSourcePatchOutput) ToResourceMetricSourcePatchPtrOutputWit }).(ResourceMetricSourcePatchPtrOutput) } +func (o ResourceMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSourcePatch] { + return pulumix.Output[ResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource in question. func (o ResourceMetricSourcePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceMetricSourcePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -7421,6 +8472,12 @@ func (o ResourceMetricSourcePatchPtrOutput) ToResourceMetricSourcePatchPtrOutput return o } +func (o ResourceMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSourcePatch] { + return pulumix.Output[*ResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricSourcePatchPtrOutput) Elem() ResourceMetricSourcePatchOutput { return o.ApplyT(func(v *ResourceMetricSourcePatch) ResourceMetricSourcePatch { if v != nil { @@ -7490,6 +8547,12 @@ func (i ResourceMetricStatusArgs) ToResourceMetricStatusOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusOutput) } +func (i ResourceMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatus] { + return pulumix.Output[ResourceMetricStatus]{ + OutputState: i.ToResourceMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricStatusArgs) ToResourceMetricStatusPtrOutput() ResourceMetricStatusPtrOutput { return i.ToResourceMetricStatusPtrOutputWithContext(context.Background()) } @@ -7531,6 +8594,12 @@ func (i *resourceMetricStatusPtrType) ToResourceMetricStatusPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPtrOutput) } +func (i *resourceMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatus] { + return pulumix.Output[*ResourceMetricStatus]{ + OutputState: i.ToResourceMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ResourceMetricStatusOutput struct{ *pulumi.OutputState } @@ -7556,6 +8625,12 @@ func (o ResourceMetricStatusOutput) ToResourceMetricStatusPtrOutputWithContext(c }).(ResourceMetricStatusPtrOutput) } +func (o ResourceMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatus] { + return pulumix.Output[ResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ResourceMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v ResourceMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -7580,6 +8655,12 @@ func (o ResourceMetricStatusPtrOutput) ToResourceMetricStatusPtrOutputWithContex return o } +func (o ResourceMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatus] { + return pulumix.Output[*ResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricStatusPtrOutput) Elem() ResourceMetricStatusOutput { return o.ApplyT(func(v *ResourceMetricStatus) ResourceMetricStatus { if v != nil { @@ -7649,6 +8730,12 @@ func (i ResourceMetricStatusPatchArgs) ToResourceMetricStatusPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPatchOutput) } +func (i ResourceMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatusPatch] { + return pulumix.Output[ResourceMetricStatusPatch]{ + OutputState: i.ToResourceMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricStatusPatchArgs) ToResourceMetricStatusPatchPtrOutput() ResourceMetricStatusPatchPtrOutput { return i.ToResourceMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -7690,6 +8777,12 @@ func (i *resourceMetricStatusPatchPtrType) ToResourceMetricStatusPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPatchPtrOutput) } +func (i *resourceMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatusPatch] { + return pulumix.Output[*ResourceMetricStatusPatch]{ + OutputState: i.ToResourceMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ResourceMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -7715,6 +8808,12 @@ func (o ResourceMetricStatusPatchOutput) ToResourceMetricStatusPatchPtrOutputWit }).(ResourceMetricStatusPatchPtrOutput) } +func (o ResourceMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatusPatch] { + return pulumix.Output[ResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ResourceMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v ResourceMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -7739,6 +8838,12 @@ func (o ResourceMetricStatusPatchPtrOutput) ToResourceMetricStatusPatchPtrOutput return o } +func (o ResourceMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatusPatch] { + return pulumix.Output[*ResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricStatusPatchPtrOutput) Elem() ResourceMetricStatusPatchOutput { return o.ApplyT(func(v *ResourceMetricStatusPatch) ResourceMetricStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscaler.go b/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscaler.go index 0604e2cc0b..c9eccd653e 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscaler.go +++ b/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscaler.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. @@ -127,6 +128,12 @@ func (i *HorizontalPodAutoscaler) ToHorizontalPodAutoscalerOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerOutput) } +func (i *HorizontalPodAutoscaler) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerArrayInput is an input type that accepts HorizontalPodAutoscalerArray and HorizontalPodAutoscalerArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerArrayInput` via: // @@ -152,6 +159,12 @@ func (i HorizontalPodAutoscalerArray) ToHorizontalPodAutoscalerArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerArrayOutput) } +func (i HorizontalPodAutoscalerArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerMapInput is an input type that accepts HorizontalPodAutoscalerMap and HorizontalPodAutoscalerMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerMapInput` via: // @@ -177,6 +190,12 @@ func (i HorizontalPodAutoscalerMap) ToHorizontalPodAutoscalerMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerMapOutput) } +func (i HorizontalPodAutoscalerMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o HorizontalPodAutoscalerOutput) ToHorizontalPodAutoscalerOutputWithContex return o } +func (o HorizontalPodAutoscalerOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscaler) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o HorizontalPodAutoscalerArrayOutput) ToHorizontalPodAutoscalerArrayOutput return o } +func (o HorizontalPodAutoscalerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].([]*HorizontalPodAutoscaler)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o HorizontalPodAutoscalerMapOutput) ToHorizontalPodAutoscalerMapOutputWith return o } +func (o HorizontalPodAutoscalerMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].(map[string]*HorizontalPodAutoscaler)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerList.go b/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerList.go index c77bfec44e..7f035573df 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerList.go +++ b/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // HorizontalPodAutoscaler is a list of horizontal pod autoscaler objects. @@ -117,6 +118,12 @@ func (i *HorizontalPodAutoscalerList) ToHorizontalPodAutoscalerListOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListOutput) } +func (i *HorizontalPodAutoscalerList) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListArrayInput is an input type that accepts HorizontalPodAutoscalerListArray and HorizontalPodAutoscalerListArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListArrayInput` via: // @@ -142,6 +149,12 @@ func (i HorizontalPodAutoscalerListArray) ToHorizontalPodAutoscalerListArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListArrayOutput) } +func (i HorizontalPodAutoscalerListArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListMapInput is an input type that accepts HorizontalPodAutoscalerListMap and HorizontalPodAutoscalerListMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListMapInput` via: // @@ -167,6 +180,12 @@ func (i HorizontalPodAutoscalerListMap) ToHorizontalPodAutoscalerListMapOutputWi return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListMapOutput) } +func (i HorizontalPodAutoscalerListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerListOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o HorizontalPodAutoscalerListOutput) ToHorizontalPodAutoscalerListOutputWi return o } +func (o HorizontalPodAutoscalerListOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o HorizontalPodAutoscalerListArrayOutput) ToHorizontalPodAutoscalerListArr return o } +func (o HorizontalPodAutoscalerListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].([]*HorizontalPodAutoscalerList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o HorizontalPodAutoscalerListMapOutput) ToHorizontalPodAutoscalerListMapOu return o } +func (o HorizontalPodAutoscalerListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].(map[string]*HorizontalPodAutoscalerList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerPatch.go b/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerPatch.go index f9375e37f5..4de4c2704a 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerPatch.go +++ b/sdk/go/kubernetes/autoscaling/v2beta1/horizontalPodAutoscalerPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *HorizontalPodAutoscalerPatch) ToHorizontalPodAutoscalerPatchOutputWithC return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchOutput) } +func (i *HorizontalPodAutoscalerPatch) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchArrayInput is an input type that accepts HorizontalPodAutoscalerPatchArray and HorizontalPodAutoscalerPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i HorizontalPodAutoscalerPatchArray) ToHorizontalPodAutoscalerPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchArrayOutput) } +func (i HorizontalPodAutoscalerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchMapInput is an input type that accepts HorizontalPodAutoscalerPatchMap and HorizontalPodAutoscalerPatchMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i HorizontalPodAutoscalerPatchMap) ToHorizontalPodAutoscalerPatchMapOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchMapOutput) } +func (i HorizontalPodAutoscalerPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerPatchOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o HorizontalPodAutoscalerPatchOutput) ToHorizontalPodAutoscalerPatchOutput return o } +func (o HorizontalPodAutoscalerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o HorizontalPodAutoscalerPatchArrayOutput) ToHorizontalPodAutoscalerPatchA return o } +func (o HorizontalPodAutoscalerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].([]*HorizontalPodAutoscalerPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o HorizontalPodAutoscalerPatchMapOutput) ToHorizontalPodAutoscalerPatchMap return o } +func (o HorizontalPodAutoscalerPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].(map[string]*HorizontalPodAutoscalerPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2beta1/pulumiTypes.go b/sdk/go/kubernetes/autoscaling/v2beta1/pulumiTypes.go index b686e39cc5..7eda1436e1 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/autoscaling/v2beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -61,6 +62,12 @@ func (i ContainerResourceMetricSourceArgs) ToContainerResourceMetricSourceOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourceOutput) } +func (i ContainerResourceMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSource] { + return pulumix.Output[ContainerResourceMetricSource]{ + OutputState: i.ToContainerResourceMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricSourceArgs) ToContainerResourceMetricSourcePtrOutput() ContainerResourceMetricSourcePtrOutput { return i.ToContainerResourceMetricSourcePtrOutputWithContext(context.Background()) } @@ -102,6 +109,12 @@ func (i *containerResourceMetricSourcePtrType) ToContainerResourceMetricSourcePt return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePtrOutput) } +func (i *containerResourceMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSource] { + return pulumix.Output[*ContainerResourceMetricSource]{ + OutputState: i.ToContainerResourceMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ContainerResourceMetricSourceOutput struct{ *pulumi.OutputState } @@ -127,6 +140,12 @@ func (o ContainerResourceMetricSourceOutput) ToContainerResourceMetricSourcePtrO }).(ContainerResourceMetricSourcePtrOutput) } +func (o ContainerResourceMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSource] { + return pulumix.Output[ContainerResourceMetricSource]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricSourceOutput) Container() pulumi.StringOutput { return o.ApplyT(func(v ContainerResourceMetricSource) string { return v.Container }).(pulumi.StringOutput) @@ -161,6 +180,12 @@ func (o ContainerResourceMetricSourcePtrOutput) ToContainerResourceMetricSourceP return o } +func (o ContainerResourceMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSource] { + return pulumix.Output[*ContainerResourceMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricSourcePtrOutput) Elem() ContainerResourceMetricSourceOutput { return o.ApplyT(func(v *ContainerResourceMetricSource) ContainerResourceMetricSource { if v != nil { @@ -258,6 +283,12 @@ func (i ContainerResourceMetricSourcePatchArgs) ToContainerResourceMetricSourceP return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePatchOutput) } +func (i ContainerResourceMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSourcePatch] { + return pulumix.Output[ContainerResourceMetricSourcePatch]{ + OutputState: i.ToContainerResourceMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricSourcePatchArgs) ToContainerResourceMetricSourcePatchPtrOutput() ContainerResourceMetricSourcePatchPtrOutput { return i.ToContainerResourceMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -299,6 +330,12 @@ func (i *containerResourceMetricSourcePatchPtrType) ToContainerResourceMetricSou return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePatchPtrOutput) } +func (i *containerResourceMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSourcePatch] { + return pulumix.Output[*ContainerResourceMetricSourcePatch]{ + OutputState: i.ToContainerResourceMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ContainerResourceMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -324,6 +361,12 @@ func (o ContainerResourceMetricSourcePatchOutput) ToContainerResourceMetricSourc }).(ContainerResourceMetricSourcePatchPtrOutput) } +func (o ContainerResourceMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSourcePatch] { + return pulumix.Output[ContainerResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricSourcePatchOutput) Container() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResourceMetricSourcePatch) *string { return v.Container }).(pulumi.StringPtrOutput) @@ -358,6 +401,12 @@ func (o ContainerResourceMetricSourcePatchPtrOutput) ToContainerResourceMetricSo return o } +func (o ContainerResourceMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSourcePatch] { + return pulumix.Output[*ContainerResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricSourcePatchPtrOutput) Elem() ContainerResourceMetricSourcePatchOutput { return o.ApplyT(func(v *ContainerResourceMetricSourcePatch) ContainerResourceMetricSourcePatch { if v != nil { @@ -455,6 +504,12 @@ func (i ContainerResourceMetricStatusArgs) ToContainerResourceMetricStatusOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusOutput) } +func (i ContainerResourceMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatus] { + return pulumix.Output[ContainerResourceMetricStatus]{ + OutputState: i.ToContainerResourceMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricStatusArgs) ToContainerResourceMetricStatusPtrOutput() ContainerResourceMetricStatusPtrOutput { return i.ToContainerResourceMetricStatusPtrOutputWithContext(context.Background()) } @@ -496,6 +551,12 @@ func (i *containerResourceMetricStatusPtrType) ToContainerResourceMetricStatusPt return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPtrOutput) } +func (i *containerResourceMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatus] { + return pulumix.Output[*ContainerResourceMetricStatus]{ + OutputState: i.ToContainerResourceMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ContainerResourceMetricStatusOutput struct{ *pulumi.OutputState } @@ -521,6 +582,12 @@ func (o ContainerResourceMetricStatusOutput) ToContainerResourceMetricStatusPtrO }).(ContainerResourceMetricStatusPtrOutput) } +func (o ContainerResourceMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatus] { + return pulumix.Output[ContainerResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricStatusOutput) Container() pulumi.StringOutput { return o.ApplyT(func(v ContainerResourceMetricStatus) string { return v.Container }).(pulumi.StringOutput) @@ -555,6 +622,12 @@ func (o ContainerResourceMetricStatusPtrOutput) ToContainerResourceMetricStatusP return o } +func (o ContainerResourceMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatus] { + return pulumix.Output[*ContainerResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricStatusPtrOutput) Elem() ContainerResourceMetricStatusOutput { return o.ApplyT(func(v *ContainerResourceMetricStatus) ContainerResourceMetricStatus { if v != nil { @@ -652,6 +725,12 @@ func (i ContainerResourceMetricStatusPatchArgs) ToContainerResourceMetricStatusP return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPatchOutput) } +func (i ContainerResourceMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatusPatch] { + return pulumix.Output[ContainerResourceMetricStatusPatch]{ + OutputState: i.ToContainerResourceMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricStatusPatchArgs) ToContainerResourceMetricStatusPatchPtrOutput() ContainerResourceMetricStatusPatchPtrOutput { return i.ToContainerResourceMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -693,6 +772,12 @@ func (i *containerResourceMetricStatusPatchPtrType) ToContainerResourceMetricSta return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPatchPtrOutput) } +func (i *containerResourceMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatusPatch] { + return pulumix.Output[*ContainerResourceMetricStatusPatch]{ + OutputState: i.ToContainerResourceMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ContainerResourceMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -718,6 +803,12 @@ func (o ContainerResourceMetricStatusPatchOutput) ToContainerResourceMetricStatu }).(ContainerResourceMetricStatusPatchPtrOutput) } +func (o ContainerResourceMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatusPatch] { + return pulumix.Output[ContainerResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricStatusPatchOutput) Container() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResourceMetricStatusPatch) *string { return v.Container }).(pulumi.StringPtrOutput) @@ -752,6 +843,12 @@ func (o ContainerResourceMetricStatusPatchPtrOutput) ToContainerResourceMetricSt return o } +func (o ContainerResourceMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatusPatch] { + return pulumix.Output[*ContainerResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricStatusPatchPtrOutput) Elem() ContainerResourceMetricStatusPatchOutput { return o.ApplyT(func(v *ContainerResourceMetricStatusPatch) ContainerResourceMetricStatusPatch { if v != nil { @@ -845,6 +942,12 @@ func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferenceOutputWith return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferenceOutput) } +func (i CrossVersionObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferencePtrOutput() CrossVersionObjectReferencePtrOutput { return i.ToCrossVersionObjectReferencePtrOutputWithContext(context.Background()) } @@ -886,6 +989,12 @@ func (i *crossVersionObjectReferencePtrType) ToCrossVersionObjectReferencePtrOut return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePtrOutput) } +func (i *crossVersionObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferenceOutput struct{ *pulumi.OutputState } @@ -911,6 +1020,12 @@ func (o CrossVersionObjectReferenceOutput) ToCrossVersionObjectReferencePtrOutpu }).(CrossVersionObjectReferencePtrOutput) } +func (o CrossVersionObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + // API version of the referent func (o CrossVersionObjectReferenceOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReference) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -940,6 +1055,12 @@ func (o CrossVersionObjectReferencePtrOutput) ToCrossVersionObjectReferencePtrOu return o } +func (o CrossVersionObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePtrOutput) Elem() CrossVersionObjectReferenceOutput { return o.ApplyT(func(v *CrossVersionObjectReference) CrossVersionObjectReference { if v != nil { @@ -1023,6 +1144,12 @@ func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatch return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchOutput) } +func (i CrossVersionObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatchPtrOutput() CrossVersionObjectReferencePatchPtrOutput { return i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -1064,6 +1191,12 @@ func (i *crossVersionObjectReferencePatchPtrType) ToCrossVersionObjectReferenceP return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchPtrOutput) } +func (i *crossVersionObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -1089,6 +1222,12 @@ func (o CrossVersionObjectReferencePatchOutput) ToCrossVersionObjectReferencePat }).(CrossVersionObjectReferencePatchPtrOutput) } +func (o CrossVersionObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // API version of the referent func (o CrossVersionObjectReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1118,6 +1257,12 @@ func (o CrossVersionObjectReferencePatchPtrOutput) ToCrossVersionObjectReference return o } +func (o CrossVersionObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePatchPtrOutput) Elem() CrossVersionObjectReferencePatchOutput { return o.ApplyT(func(v *CrossVersionObjectReferencePatch) CrossVersionObjectReferencePatch { if v != nil { @@ -1205,6 +1350,12 @@ func (i ExternalMetricSourceArgs) ToExternalMetricSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourceOutput) } +func (i ExternalMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSource] { + return pulumix.Output[ExternalMetricSource]{ + OutputState: i.ToExternalMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricSourceArgs) ToExternalMetricSourcePtrOutput() ExternalMetricSourcePtrOutput { return i.ToExternalMetricSourcePtrOutputWithContext(context.Background()) } @@ -1246,6 +1397,12 @@ func (i *externalMetricSourcePtrType) ToExternalMetricSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePtrOutput) } +func (i *externalMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSource] { + return pulumix.Output[*ExternalMetricSource]{ + OutputState: i.ToExternalMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). Exactly one "target" type should be set. type ExternalMetricSourceOutput struct{ *pulumi.OutputState } @@ -1271,6 +1428,12 @@ func (o ExternalMetricSourceOutput) ToExternalMetricSourcePtrOutputWithContext(c }).(ExternalMetricSourcePtrOutput) } +func (o ExternalMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSource] { + return pulumix.Output[ExternalMetricSource]{ + OutputState: o.OutputState, + } +} + // metricName is the name of the metric in question. func (o ExternalMetricSourceOutput) MetricName() pulumi.StringOutput { return o.ApplyT(func(v ExternalMetricSource) string { return v.MetricName }).(pulumi.StringOutput) @@ -1305,6 +1468,12 @@ func (o ExternalMetricSourcePtrOutput) ToExternalMetricSourcePtrOutputWithContex return o } +func (o ExternalMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSource] { + return pulumix.Output[*ExternalMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricSourcePtrOutput) Elem() ExternalMetricSourceOutput { return o.ApplyT(func(v *ExternalMetricSource) ExternalMetricSource { if v != nil { @@ -1402,6 +1571,12 @@ func (i ExternalMetricSourcePatchArgs) ToExternalMetricSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePatchOutput) } +func (i ExternalMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSourcePatch] { + return pulumix.Output[ExternalMetricSourcePatch]{ + OutputState: i.ToExternalMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricSourcePatchArgs) ToExternalMetricSourcePatchPtrOutput() ExternalMetricSourcePatchPtrOutput { return i.ToExternalMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -1443,6 +1618,12 @@ func (i *externalMetricSourcePatchPtrType) ToExternalMetricSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePatchPtrOutput) } +func (i *externalMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSourcePatch] { + return pulumix.Output[*ExternalMetricSourcePatch]{ + OutputState: i.ToExternalMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). Exactly one "target" type should be set. type ExternalMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -1468,6 +1649,12 @@ func (o ExternalMetricSourcePatchOutput) ToExternalMetricSourcePatchPtrOutputWit }).(ExternalMetricSourcePatchPtrOutput) } +func (o ExternalMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSourcePatch] { + return pulumix.Output[ExternalMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // metricName is the name of the metric in question. func (o ExternalMetricSourcePatchOutput) MetricName() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalMetricSourcePatch) *string { return v.MetricName }).(pulumi.StringPtrOutput) @@ -1502,6 +1689,12 @@ func (o ExternalMetricSourcePatchPtrOutput) ToExternalMetricSourcePatchPtrOutput return o } +func (o ExternalMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSourcePatch] { + return pulumix.Output[*ExternalMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricSourcePatchPtrOutput) Elem() ExternalMetricSourcePatchOutput { return o.ApplyT(func(v *ExternalMetricSourcePatch) ExternalMetricSourcePatch { if v != nil { @@ -1599,6 +1792,12 @@ func (i ExternalMetricStatusArgs) ToExternalMetricStatusOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusOutput) } +func (i ExternalMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatus] { + return pulumix.Output[ExternalMetricStatus]{ + OutputState: i.ToExternalMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricStatusArgs) ToExternalMetricStatusPtrOutput() ExternalMetricStatusPtrOutput { return i.ToExternalMetricStatusPtrOutputWithContext(context.Background()) } @@ -1640,6 +1839,12 @@ func (i *externalMetricStatusPtrType) ToExternalMetricStatusPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPtrOutput) } +func (i *externalMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatus] { + return pulumix.Output[*ExternalMetricStatus]{ + OutputState: i.ToExternalMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. type ExternalMetricStatusOutput struct{ *pulumi.OutputState } @@ -1665,6 +1870,12 @@ func (o ExternalMetricStatusOutput) ToExternalMetricStatusPtrOutputWithContext(c }).(ExternalMetricStatusPtrOutput) } +func (o ExternalMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatus] { + return pulumix.Output[ExternalMetricStatus]{ + OutputState: o.OutputState, + } +} + // currentAverageValue is the current value of metric averaged over autoscaled pods. func (o ExternalMetricStatusOutput) CurrentAverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalMetricStatus) *string { return v.CurrentAverageValue }).(pulumi.StringPtrOutput) @@ -1699,6 +1910,12 @@ func (o ExternalMetricStatusPtrOutput) ToExternalMetricStatusPtrOutputWithContex return o } +func (o ExternalMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatus] { + return pulumix.Output[*ExternalMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricStatusPtrOutput) Elem() ExternalMetricStatusOutput { return o.ApplyT(func(v *ExternalMetricStatus) ExternalMetricStatus { if v != nil { @@ -1796,6 +2013,12 @@ func (i ExternalMetricStatusPatchArgs) ToExternalMetricStatusPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPatchOutput) } +func (i ExternalMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatusPatch] { + return pulumix.Output[ExternalMetricStatusPatch]{ + OutputState: i.ToExternalMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricStatusPatchArgs) ToExternalMetricStatusPatchPtrOutput() ExternalMetricStatusPatchPtrOutput { return i.ToExternalMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -1837,6 +2060,12 @@ func (i *externalMetricStatusPatchPtrType) ToExternalMetricStatusPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPatchPtrOutput) } +func (i *externalMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatusPatch] { + return pulumix.Output[*ExternalMetricStatusPatch]{ + OutputState: i.ToExternalMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. type ExternalMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -1862,6 +2091,12 @@ func (o ExternalMetricStatusPatchOutput) ToExternalMetricStatusPatchPtrOutputWit }).(ExternalMetricStatusPatchPtrOutput) } +func (o ExternalMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatusPatch] { + return pulumix.Output[ExternalMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // currentAverageValue is the current value of metric averaged over autoscaled pods. func (o ExternalMetricStatusPatchOutput) CurrentAverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v ExternalMetricStatusPatch) *string { return v.CurrentAverageValue }).(pulumi.StringPtrOutput) @@ -1896,6 +2131,12 @@ func (o ExternalMetricStatusPatchPtrOutput) ToExternalMetricStatusPatchPtrOutput return o } +func (o ExternalMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatusPatch] { + return pulumix.Output[*ExternalMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricStatusPatchPtrOutput) Elem() ExternalMetricStatusPatchOutput { return o.ApplyT(func(v *ExternalMetricStatusPatch) ExternalMetricStatusPatch { if v != nil { @@ -1997,6 +2238,12 @@ func (i HorizontalPodAutoscalerTypeArgs) ToHorizontalPodAutoscalerTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeOutput) } +func (i HorizontalPodAutoscalerTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerTypeArrayInput is an input type that accepts HorizontalPodAutoscalerTypeArray and HorizontalPodAutoscalerTypeArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerTypeArrayInput` via: // @@ -2022,6 +2269,12 @@ func (i HorizontalPodAutoscalerTypeArray) ToHorizontalPodAutoscalerTypeArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeArrayOutput) } +func (i HorizontalPodAutoscalerTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. type HorizontalPodAutoscalerTypeOutput struct{ *pulumi.OutputState } @@ -2037,6 +2290,12 @@ func (o HorizontalPodAutoscalerTypeOutput) ToHorizontalPodAutoscalerTypeOutputWi return o } +func (o HorizontalPodAutoscalerTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2076,6 +2335,12 @@ func (o HorizontalPodAutoscalerTypeArrayOutput) ToHorizontalPodAutoscalerTypeArr return o } +func (o HorizontalPodAutoscalerTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerTypeArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerType { return vs[0].([]HorizontalPodAutoscalerType)[vs[1].(int)] @@ -2133,6 +2398,12 @@ func (i HorizontalPodAutoscalerConditionArgs) ToHorizontalPodAutoscalerCondition return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionOutput) } +func (i HorizontalPodAutoscalerConditionArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerCondition] { + return pulumix.Output[HorizontalPodAutoscalerCondition]{ + OutputState: i.ToHorizontalPodAutoscalerConditionOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerConditionArrayInput is an input type that accepts HorizontalPodAutoscalerConditionArray and HorizontalPodAutoscalerConditionArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerConditionArrayInput` via: // @@ -2158,6 +2429,12 @@ func (i HorizontalPodAutoscalerConditionArray) ToHorizontalPodAutoscalerConditio return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionArrayOutput) } +func (i HorizontalPodAutoscalerConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerCondition] { + return pulumix.Output[[]HorizontalPodAutoscalerCondition]{ + OutputState: i.ToHorizontalPodAutoscalerConditionArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. type HorizontalPodAutoscalerConditionOutput struct{ *pulumi.OutputState } @@ -2173,6 +2450,12 @@ func (o HorizontalPodAutoscalerConditionOutput) ToHorizontalPodAutoscalerConditi return o } +func (o HorizontalPodAutoscalerConditionOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerCondition] { + return pulumix.Output[HorizontalPodAutoscalerCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another func (o HorizontalPodAutoscalerConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2212,6 +2495,12 @@ func (o HorizontalPodAutoscalerConditionArrayOutput) ToHorizontalPodAutoscalerCo return o } +func (o HorizontalPodAutoscalerConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerCondition] { + return pulumix.Output[[]HorizontalPodAutoscalerCondition]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerConditionArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerCondition { return vs[0].([]HorizontalPodAutoscalerCondition)[vs[1].(int)] @@ -2269,6 +2558,12 @@ func (i HorizontalPodAutoscalerConditionPatchArgs) ToHorizontalPodAutoscalerCond return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionPatchOutput) } +func (i HorizontalPodAutoscalerConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[HorizontalPodAutoscalerConditionPatch]{ + OutputState: i.ToHorizontalPodAutoscalerConditionPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerConditionPatchArrayInput is an input type that accepts HorizontalPodAutoscalerConditionPatchArray and HorizontalPodAutoscalerConditionPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerConditionPatchArrayInput` via: // @@ -2294,6 +2589,12 @@ func (i HorizontalPodAutoscalerConditionPatchArray) ToHorizontalPodAutoscalerCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionPatchArrayOutput) } +func (i HorizontalPodAutoscalerConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[[]HorizontalPodAutoscalerConditionPatch]{ + OutputState: i.ToHorizontalPodAutoscalerConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. type HorizontalPodAutoscalerConditionPatchOutput struct{ *pulumi.OutputState } @@ -2309,6 +2610,12 @@ func (o HorizontalPodAutoscalerConditionPatchOutput) ToHorizontalPodAutoscalerCo return o } +func (o HorizontalPodAutoscalerConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[HorizontalPodAutoscalerConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another func (o HorizontalPodAutoscalerConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2348,6 +2655,12 @@ func (o HorizontalPodAutoscalerConditionPatchArrayOutput) ToHorizontalPodAutosca return o } +func (o HorizontalPodAutoscalerConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[[]HorizontalPodAutoscalerConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerConditionPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerConditionPatch { return vs[0].([]HorizontalPodAutoscalerConditionPatch)[vs[1].(int)] @@ -2401,6 +2714,12 @@ func (i HorizontalPodAutoscalerListTypeArgs) ToHorizontalPodAutoscalerListTypeOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListTypeOutput) } +func (i HorizontalPodAutoscalerListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: i.ToHorizontalPodAutoscalerListTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is a list of horizontal pod autoscaler objects. type HorizontalPodAutoscalerListTypeOutput struct{ *pulumi.OutputState } @@ -2416,6 +2735,12 @@ func (o HorizontalPodAutoscalerListTypeOutput) ToHorizontalPodAutoscalerListType return o } +func (o HorizontalPodAutoscalerListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2487,6 +2812,12 @@ func (i HorizontalPodAutoscalerPatchTypeArgs) ToHorizontalPodAutoscalerPatchType return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchTypeOutput) } +func (i HorizontalPodAutoscalerPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: i.ToHorizontalPodAutoscalerPatchTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. type HorizontalPodAutoscalerPatchTypeOutput struct{ *pulumi.OutputState } @@ -2502,6 +2833,12 @@ func (o HorizontalPodAutoscalerPatchTypeOutput) ToHorizontalPodAutoscalerPatchTy return o } +func (o HorizontalPodAutoscalerPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2574,6 +2911,12 @@ func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecOutput) } +func (i HorizontalPodAutoscalerSpecArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecPtrOutput() HorizontalPodAutoscalerSpecPtrOutput { return i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(context.Background()) } @@ -2615,6 +2958,12 @@ func (i *horizontalPodAutoscalerSpecPtrType) ToHorizontalPodAutoscalerSpecPtrOut return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPtrOutput) } +func (i *horizontalPodAutoscalerSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. type HorizontalPodAutoscalerSpecOutput struct{ *pulumi.OutputState } @@ -2640,6 +2989,12 @@ func (o HorizontalPodAutoscalerSpecOutput) ToHorizontalPodAutoscalerSpecPtrOutpu }).(HorizontalPodAutoscalerSpecPtrOutput) } +func (o HorizontalPodAutoscalerSpecOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + // maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. func (o HorizontalPodAutoscalerSpecOutput) MaxReplicas() pulumi.IntOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpec) int { return v.MaxReplicas }).(pulumi.IntOutput) @@ -2674,6 +3029,12 @@ func (o HorizontalPodAutoscalerSpecPtrOutput) ToHorizontalPodAutoscalerSpecPtrOu return o } +func (o HorizontalPodAutoscalerSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPtrOutput) Elem() HorizontalPodAutoscalerSpecOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpec) HorizontalPodAutoscalerSpec { if v != nil { @@ -2771,6 +3132,12 @@ func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatch return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchOutput) } +func (i HorizontalPodAutoscalerSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatchPtrOutput() HorizontalPodAutoscalerSpecPatchPtrOutput { return i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(context.Background()) } @@ -2812,6 +3179,12 @@ func (i *horizontalPodAutoscalerSpecPatchPtrType) ToHorizontalPodAutoscalerSpecP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (i *horizontalPodAutoscalerSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. type HorizontalPodAutoscalerSpecPatchOutput struct{ *pulumi.OutputState } @@ -2837,6 +3210,12 @@ func (o HorizontalPodAutoscalerSpecPatchOutput) ToHorizontalPodAutoscalerSpecPat }).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (o HorizontalPodAutoscalerSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + // maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. func (o HorizontalPodAutoscalerSpecPatchOutput) MaxReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpecPatch) *int { return v.MaxReplicas }).(pulumi.IntPtrOutput) @@ -2871,6 +3250,12 @@ func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToHorizontalPodAutoscalerSpec return o } +func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPatchPtrOutput) Elem() HorizontalPodAutoscalerSpecPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpecPatch) HorizontalPodAutoscalerSpecPatch { if v != nil { @@ -2976,6 +3361,12 @@ func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusOutput) } +func (i HorizontalPodAutoscalerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusPtrOutput() HorizontalPodAutoscalerStatusPtrOutput { return i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(context.Background()) } @@ -3017,6 +3408,12 @@ func (i *horizontalPodAutoscalerStatusPtrType) ToHorizontalPodAutoscalerStatusPt return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPtrOutput) } +func (i *horizontalPodAutoscalerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. type HorizontalPodAutoscalerStatusOutput struct{ *pulumi.OutputState } @@ -3042,6 +3439,12 @@ func (o HorizontalPodAutoscalerStatusOutput) ToHorizontalPodAutoscalerStatusPtrO }).(HorizontalPodAutoscalerStatusPtrOutput) } +func (o HorizontalPodAutoscalerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + // conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. func (o HorizontalPodAutoscalerStatusOutput) Conditions() HorizontalPodAutoscalerConditionArrayOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatus) []HorizontalPodAutoscalerCondition { return v.Conditions }).(HorizontalPodAutoscalerConditionArrayOutput) @@ -3086,6 +3489,12 @@ func (o HorizontalPodAutoscalerStatusPtrOutput) ToHorizontalPodAutoscalerStatusP return o } +func (o HorizontalPodAutoscalerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPtrOutput) Elem() HorizontalPodAutoscalerStatusOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatus) HorizontalPodAutoscalerStatus { if v != nil { @@ -3211,6 +3620,12 @@ func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchOutput) } +func (i HorizontalPodAutoscalerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusPatchPtrOutput() HorizontalPodAutoscalerStatusPatchPtrOutput { return i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(context.Background()) } @@ -3252,6 +3667,12 @@ func (i *horizontalPodAutoscalerStatusPatchPtrType) ToHorizontalPodAutoscalerSta return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (i *horizontalPodAutoscalerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. type HorizontalPodAutoscalerStatusPatchOutput struct{ *pulumi.OutputState } @@ -3277,6 +3698,12 @@ func (o HorizontalPodAutoscalerStatusPatchOutput) ToHorizontalPodAutoscalerStatu }).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (o HorizontalPodAutoscalerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + // conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. func (o HorizontalPodAutoscalerStatusPatchOutput) Conditions() HorizontalPodAutoscalerConditionPatchArrayOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatusPatch) []HorizontalPodAutoscalerConditionPatch { @@ -3323,6 +3750,12 @@ func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToHorizontalPodAutoscalerSt return o } +func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPatchPtrOutput) Elem() HorizontalPodAutoscalerStatusPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatusPatch) HorizontalPodAutoscalerStatusPatch { if v != nil { @@ -3448,6 +3881,12 @@ func (i MetricSpecArgs) ToMetricSpecOutputWithContext(ctx context.Context) Metri return pulumi.ToOutputWithContext(ctx, i).(MetricSpecOutput) } +func (i MetricSpecArgs) ToOutput(ctx context.Context) pulumix.Output[MetricSpec] { + return pulumix.Output[MetricSpec]{ + OutputState: i.ToMetricSpecOutputWithContext(ctx).OutputState, + } +} + // MetricSpecArrayInput is an input type that accepts MetricSpecArray and MetricSpecArrayOutput values. // You can construct a concrete instance of `MetricSpecArrayInput` via: // @@ -3473,6 +3912,12 @@ func (i MetricSpecArray) ToMetricSpecArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(MetricSpecArrayOutput) } +func (i MetricSpecArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpec] { + return pulumix.Output[[]MetricSpec]{ + OutputState: i.ToMetricSpecArrayOutputWithContext(ctx).OutputState, + } +} + // MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). type MetricSpecOutput struct{ *pulumi.OutputState } @@ -3488,6 +3933,12 @@ func (o MetricSpecOutput) ToMetricSpecOutputWithContext(ctx context.Context) Met return o } +func (o MetricSpecOutput) ToOutput(ctx context.Context) pulumix.Output[MetricSpec] { + return pulumix.Output[MetricSpec]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. func (o MetricSpecOutput) ContainerResource() ContainerResourceMetricSourcePtrOutput { return o.ApplyT(func(v MetricSpec) *ContainerResourceMetricSource { return v.ContainerResource }).(ContainerResourceMetricSourcePtrOutput) @@ -3532,6 +3983,12 @@ func (o MetricSpecArrayOutput) ToMetricSpecArrayOutputWithContext(ctx context.Co return o } +func (o MetricSpecArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpec] { + return pulumix.Output[[]MetricSpec]{ + OutputState: o.OutputState, + } +} + func (o MetricSpecArrayOutput) Index(i pulumi.IntInput) MetricSpecOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricSpec { return vs[0].([]MetricSpec)[vs[1].(int)] @@ -3593,6 +4050,12 @@ func (i MetricSpecPatchArgs) ToMetricSpecPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MetricSpecPatchOutput) } +func (i MetricSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricSpecPatch] { + return pulumix.Output[MetricSpecPatch]{ + OutputState: i.ToMetricSpecPatchOutputWithContext(ctx).OutputState, + } +} + // MetricSpecPatchArrayInput is an input type that accepts MetricSpecPatchArray and MetricSpecPatchArrayOutput values. // You can construct a concrete instance of `MetricSpecPatchArrayInput` via: // @@ -3618,6 +4081,12 @@ func (i MetricSpecPatchArray) ToMetricSpecPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(MetricSpecPatchArrayOutput) } +func (i MetricSpecPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpecPatch] { + return pulumix.Output[[]MetricSpecPatch]{ + OutputState: i.ToMetricSpecPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). type MetricSpecPatchOutput struct{ *pulumi.OutputState } @@ -3633,6 +4102,12 @@ func (o MetricSpecPatchOutput) ToMetricSpecPatchOutputWithContext(ctx context.Co return o } +func (o MetricSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricSpecPatch] { + return pulumix.Output[MetricSpecPatch]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. func (o MetricSpecPatchOutput) ContainerResource() ContainerResourceMetricSourcePatchPtrOutput { return o.ApplyT(func(v MetricSpecPatch) *ContainerResourceMetricSourcePatch { return v.ContainerResource }).(ContainerResourceMetricSourcePatchPtrOutput) @@ -3677,6 +4152,12 @@ func (o MetricSpecPatchArrayOutput) ToMetricSpecPatchArrayOutputWithContext(ctx return o } +func (o MetricSpecPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpecPatch] { + return pulumix.Output[[]MetricSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricSpecPatchArrayOutput) Index(i pulumi.IntInput) MetricSpecPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricSpecPatch { return vs[0].([]MetricSpecPatch)[vs[1].(int)] @@ -3738,6 +4219,12 @@ func (i MetricStatusArgs) ToMetricStatusOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(MetricStatusOutput) } +func (i MetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[MetricStatus] { + return pulumix.Output[MetricStatus]{ + OutputState: i.ToMetricStatusOutputWithContext(ctx).OutputState, + } +} + // MetricStatusArrayInput is an input type that accepts MetricStatusArray and MetricStatusArrayOutput values. // You can construct a concrete instance of `MetricStatusArrayInput` via: // @@ -3763,6 +4250,12 @@ func (i MetricStatusArray) ToMetricStatusArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MetricStatusArrayOutput) } +func (i MetricStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatus] { + return pulumix.Output[[]MetricStatus]{ + OutputState: i.ToMetricStatusArrayOutputWithContext(ctx).OutputState, + } +} + // MetricStatus describes the last-read state of a single metric. type MetricStatusOutput struct{ *pulumi.OutputState } @@ -3778,6 +4271,12 @@ func (o MetricStatusOutput) ToMetricStatusOutputWithContext(ctx context.Context) return o } +func (o MetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[MetricStatus] { + return pulumix.Output[MetricStatus]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. func (o MetricStatusOutput) ContainerResource() ContainerResourceMetricStatusPtrOutput { return o.ApplyT(func(v MetricStatus) *ContainerResourceMetricStatus { return v.ContainerResource }).(ContainerResourceMetricStatusPtrOutput) @@ -3822,6 +4321,12 @@ func (o MetricStatusArrayOutput) ToMetricStatusArrayOutputWithContext(ctx contex return o } +func (o MetricStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatus] { + return pulumix.Output[[]MetricStatus]{ + OutputState: o.OutputState, + } +} + func (o MetricStatusArrayOutput) Index(i pulumi.IntInput) MetricStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricStatus { return vs[0].([]MetricStatus)[vs[1].(int)] @@ -3883,6 +4388,12 @@ func (i MetricStatusPatchArgs) ToMetricStatusPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricStatusPatchOutput) } +func (i MetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricStatusPatch] { + return pulumix.Output[MetricStatusPatch]{ + OutputState: i.ToMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + // MetricStatusPatchArrayInput is an input type that accepts MetricStatusPatchArray and MetricStatusPatchArrayOutput values. // You can construct a concrete instance of `MetricStatusPatchArrayInput` via: // @@ -3908,6 +4419,12 @@ func (i MetricStatusPatchArray) ToMetricStatusPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(MetricStatusPatchArrayOutput) } +func (i MetricStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatusPatch] { + return pulumix.Output[[]MetricStatusPatch]{ + OutputState: i.ToMetricStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MetricStatus describes the last-read state of a single metric. type MetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -3923,6 +4440,12 @@ func (o MetricStatusPatchOutput) ToMetricStatusPatchOutputWithContext(ctx contex return o } +func (o MetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricStatusPatch] { + return pulumix.Output[MetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. func (o MetricStatusPatchOutput) ContainerResource() ContainerResourceMetricStatusPatchPtrOutput { return o.ApplyT(func(v MetricStatusPatch) *ContainerResourceMetricStatusPatch { return v.ContainerResource }).(ContainerResourceMetricStatusPatchPtrOutput) @@ -3967,6 +4490,12 @@ func (o MetricStatusPatchArrayOutput) ToMetricStatusPatchArrayOutputWithContext( return o } +func (o MetricStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatusPatch] { + return pulumix.Output[[]MetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricStatusPatchArrayOutput) Index(i pulumi.IntInput) MetricStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricStatusPatch { return vs[0].([]MetricStatusPatch)[vs[1].(int)] @@ -4024,6 +4553,12 @@ func (i ObjectMetricSourceArgs) ToObjectMetricSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourceOutput) } +func (i ObjectMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSource] { + return pulumix.Output[ObjectMetricSource]{ + OutputState: i.ToObjectMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricSourceArgs) ToObjectMetricSourcePtrOutput() ObjectMetricSourcePtrOutput { return i.ToObjectMetricSourcePtrOutputWithContext(context.Background()) } @@ -4065,6 +4600,12 @@ func (i *objectMetricSourcePtrType) ToObjectMetricSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePtrOutput) } +func (i *objectMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSource] { + return pulumix.Output[*ObjectMetricSource]{ + OutputState: i.ToObjectMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricSourceOutput struct{ *pulumi.OutputState } @@ -4090,6 +4631,12 @@ func (o ObjectMetricSourceOutput) ToObjectMetricSourcePtrOutputWithContext(ctx c }).(ObjectMetricSourcePtrOutput) } +func (o ObjectMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSource] { + return pulumix.Output[ObjectMetricSource]{ + OutputState: o.OutputState, + } +} + // averageValue is the target value of the average of the metric across all relevant pods (as a quantity) func (o ObjectMetricSourceOutput) AverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectMetricSource) *string { return v.AverageValue }).(pulumi.StringPtrOutput) @@ -4129,6 +4676,12 @@ func (o ObjectMetricSourcePtrOutput) ToObjectMetricSourcePtrOutputWithContext(ct return o } +func (o ObjectMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSource] { + return pulumix.Output[*ObjectMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePtrOutput) Elem() ObjectMetricSourceOutput { return o.ApplyT(func(v *ObjectMetricSource) ObjectMetricSource { if v != nil { @@ -4240,6 +4793,12 @@ func (i ObjectMetricSourcePatchArgs) ToObjectMetricSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePatchOutput) } +func (i ObjectMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSourcePatch] { + return pulumix.Output[ObjectMetricSourcePatch]{ + OutputState: i.ToObjectMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricSourcePatchArgs) ToObjectMetricSourcePatchPtrOutput() ObjectMetricSourcePatchPtrOutput { return i.ToObjectMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -4281,6 +4840,12 @@ func (i *objectMetricSourcePatchPtrType) ToObjectMetricSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePatchPtrOutput) } +func (i *objectMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSourcePatch] { + return pulumix.Output[*ObjectMetricSourcePatch]{ + OutputState: i.ToObjectMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -4306,6 +4871,12 @@ func (o ObjectMetricSourcePatchOutput) ToObjectMetricSourcePatchPtrOutputWithCon }).(ObjectMetricSourcePatchPtrOutput) } +func (o ObjectMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSourcePatch] { + return pulumix.Output[ObjectMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // averageValue is the target value of the average of the metric across all relevant pods (as a quantity) func (o ObjectMetricSourcePatchOutput) AverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectMetricSourcePatch) *string { return v.AverageValue }).(pulumi.StringPtrOutput) @@ -4345,6 +4916,12 @@ func (o ObjectMetricSourcePatchPtrOutput) ToObjectMetricSourcePatchPtrOutputWith return o } +func (o ObjectMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSourcePatch] { + return pulumix.Output[*ObjectMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePatchPtrOutput) Elem() ObjectMetricSourcePatchOutput { return o.ApplyT(func(v *ObjectMetricSourcePatch) ObjectMetricSourcePatch { if v != nil { @@ -4456,6 +5033,12 @@ func (i ObjectMetricStatusArgs) ToObjectMetricStatusOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusOutput) } +func (i ObjectMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatus] { + return pulumix.Output[ObjectMetricStatus]{ + OutputState: i.ToObjectMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricStatusArgs) ToObjectMetricStatusPtrOutput() ObjectMetricStatusPtrOutput { return i.ToObjectMetricStatusPtrOutputWithContext(context.Background()) } @@ -4497,6 +5080,12 @@ func (i *objectMetricStatusPtrType) ToObjectMetricStatusPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPtrOutput) } +func (i *objectMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatus] { + return pulumix.Output[*ObjectMetricStatus]{ + OutputState: i.ToObjectMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricStatusOutput struct{ *pulumi.OutputState } @@ -4522,6 +5111,12 @@ func (o ObjectMetricStatusOutput) ToObjectMetricStatusPtrOutputWithContext(ctx c }).(ObjectMetricStatusPtrOutput) } +func (o ObjectMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatus] { + return pulumix.Output[ObjectMetricStatus]{ + OutputState: o.OutputState, + } +} + // averageValue is the current value of the average of the metric across all relevant pods (as a quantity) func (o ObjectMetricStatusOutput) AverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectMetricStatus) *string { return v.AverageValue }).(pulumi.StringPtrOutput) @@ -4561,6 +5156,12 @@ func (o ObjectMetricStatusPtrOutput) ToObjectMetricStatusPtrOutputWithContext(ct return o } +func (o ObjectMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatus] { + return pulumix.Output[*ObjectMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricStatusPtrOutput) Elem() ObjectMetricStatusOutput { return o.ApplyT(func(v *ObjectMetricStatus) ObjectMetricStatus { if v != nil { @@ -4672,6 +5273,12 @@ func (i ObjectMetricStatusPatchArgs) ToObjectMetricStatusPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPatchOutput) } +func (i ObjectMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatusPatch] { + return pulumix.Output[ObjectMetricStatusPatch]{ + OutputState: i.ToObjectMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricStatusPatchArgs) ToObjectMetricStatusPatchPtrOutput() ObjectMetricStatusPatchPtrOutput { return i.ToObjectMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -4713,6 +5320,12 @@ func (i *objectMetricStatusPatchPtrType) ToObjectMetricStatusPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPatchPtrOutput) } +func (i *objectMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatusPatch] { + return pulumix.Output[*ObjectMetricStatusPatch]{ + OutputState: i.ToObjectMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -4738,6 +5351,12 @@ func (o ObjectMetricStatusPatchOutput) ToObjectMetricStatusPatchPtrOutputWithCon }).(ObjectMetricStatusPatchPtrOutput) } +func (o ObjectMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatusPatch] { + return pulumix.Output[ObjectMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // averageValue is the current value of the average of the metric across all relevant pods (as a quantity) func (o ObjectMetricStatusPatchOutput) AverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectMetricStatusPatch) *string { return v.AverageValue }).(pulumi.StringPtrOutput) @@ -4777,6 +5396,12 @@ func (o ObjectMetricStatusPatchPtrOutput) ToObjectMetricStatusPatchPtrOutputWith return o } +func (o ObjectMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatusPatch] { + return pulumix.Output[*ObjectMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricStatusPatchPtrOutput) Elem() ObjectMetricStatusPatchOutput { return o.ApplyT(func(v *ObjectMetricStatusPatch) ObjectMetricStatusPatch { if v != nil { @@ -4880,6 +5505,12 @@ func (i PodsMetricSourceArgs) ToPodsMetricSourceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourceOutput) } +func (i PodsMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSource] { + return pulumix.Output[PodsMetricSource]{ + OutputState: i.ToPodsMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricSourceArgs) ToPodsMetricSourcePtrOutput() PodsMetricSourcePtrOutput { return i.ToPodsMetricSourcePtrOutputWithContext(context.Background()) } @@ -4921,6 +5552,12 @@ func (i *podsMetricSourcePtrType) ToPodsMetricSourcePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePtrOutput) } +func (i *podsMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSource] { + return pulumix.Output[*PodsMetricSource]{ + OutputState: i.ToPodsMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. type PodsMetricSourceOutput struct{ *pulumi.OutputState } @@ -4946,6 +5583,12 @@ func (o PodsMetricSourceOutput) ToPodsMetricSourcePtrOutputWithContext(ctx conte }).(PodsMetricSourcePtrOutput) } +func (o PodsMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSource] { + return pulumix.Output[PodsMetricSource]{ + OutputState: o.OutputState, + } +} + // metricName is the name of the metric in question func (o PodsMetricSourceOutput) MetricName() pulumi.StringOutput { return o.ApplyT(func(v PodsMetricSource) string { return v.MetricName }).(pulumi.StringOutput) @@ -4975,6 +5618,12 @@ func (o PodsMetricSourcePtrOutput) ToPodsMetricSourcePtrOutputWithContext(ctx co return o } +func (o PodsMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSource] { + return pulumix.Output[*PodsMetricSource]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricSourcePtrOutput) Elem() PodsMetricSourceOutput { return o.ApplyT(func(v *PodsMetricSource) PodsMetricSource { if v != nil { @@ -5058,6 +5707,12 @@ func (i PodsMetricSourcePatchArgs) ToPodsMetricSourcePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePatchOutput) } +func (i PodsMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSourcePatch] { + return pulumix.Output[PodsMetricSourcePatch]{ + OutputState: i.ToPodsMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricSourcePatchArgs) ToPodsMetricSourcePatchPtrOutput() PodsMetricSourcePatchPtrOutput { return i.ToPodsMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -5099,6 +5754,12 @@ func (i *podsMetricSourcePatchPtrType) ToPodsMetricSourcePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePatchPtrOutput) } +func (i *podsMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSourcePatch] { + return pulumix.Output[*PodsMetricSourcePatch]{ + OutputState: i.ToPodsMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. type PodsMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -5124,6 +5785,12 @@ func (o PodsMetricSourcePatchOutput) ToPodsMetricSourcePatchPtrOutputWithContext }).(PodsMetricSourcePatchPtrOutput) } +func (o PodsMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSourcePatch] { + return pulumix.Output[PodsMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // metricName is the name of the metric in question func (o PodsMetricSourcePatchOutput) MetricName() pulumi.StringPtrOutput { return o.ApplyT(func(v PodsMetricSourcePatch) *string { return v.MetricName }).(pulumi.StringPtrOutput) @@ -5153,6 +5820,12 @@ func (o PodsMetricSourcePatchPtrOutput) ToPodsMetricSourcePatchPtrOutputWithCont return o } +func (o PodsMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSourcePatch] { + return pulumix.Output[*PodsMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricSourcePatchPtrOutput) Elem() PodsMetricSourcePatchOutput { return o.ApplyT(func(v *PodsMetricSourcePatch) PodsMetricSourcePatch { if v != nil { @@ -5236,6 +5909,12 @@ func (i PodsMetricStatusArgs) ToPodsMetricStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusOutput) } +func (i PodsMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatus] { + return pulumix.Output[PodsMetricStatus]{ + OutputState: i.ToPodsMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricStatusArgs) ToPodsMetricStatusPtrOutput() PodsMetricStatusPtrOutput { return i.ToPodsMetricStatusPtrOutputWithContext(context.Background()) } @@ -5277,6 +5956,12 @@ func (i *podsMetricStatusPtrType) ToPodsMetricStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPtrOutput) } +func (i *podsMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatus] { + return pulumix.Output[*PodsMetricStatus]{ + OutputState: i.ToPodsMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). type PodsMetricStatusOutput struct{ *pulumi.OutputState } @@ -5302,6 +5987,12 @@ func (o PodsMetricStatusOutput) ToPodsMetricStatusPtrOutputWithContext(ctx conte }).(PodsMetricStatusPtrOutput) } +func (o PodsMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatus] { + return pulumix.Output[PodsMetricStatus]{ + OutputState: o.OutputState, + } +} + // currentAverageValue is the current value of the average of the metric across all relevant pods (as a quantity) func (o PodsMetricStatusOutput) CurrentAverageValue() pulumi.StringOutput { return o.ApplyT(func(v PodsMetricStatus) string { return v.CurrentAverageValue }).(pulumi.StringOutput) @@ -5331,6 +6022,12 @@ func (o PodsMetricStatusPtrOutput) ToPodsMetricStatusPtrOutputWithContext(ctx co return o } +func (o PodsMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatus] { + return pulumix.Output[*PodsMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricStatusPtrOutput) Elem() PodsMetricStatusOutput { return o.ApplyT(func(v *PodsMetricStatus) PodsMetricStatus { if v != nil { @@ -5414,6 +6111,12 @@ func (i PodsMetricStatusPatchArgs) ToPodsMetricStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPatchOutput) } +func (i PodsMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatusPatch] { + return pulumix.Output[PodsMetricStatusPatch]{ + OutputState: i.ToPodsMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricStatusPatchArgs) ToPodsMetricStatusPatchPtrOutput() PodsMetricStatusPatchPtrOutput { return i.ToPodsMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -5455,6 +6158,12 @@ func (i *podsMetricStatusPatchPtrType) ToPodsMetricStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPatchPtrOutput) } +func (i *podsMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatusPatch] { + return pulumix.Output[*PodsMetricStatusPatch]{ + OutputState: i.ToPodsMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). type PodsMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -5480,6 +6189,12 @@ func (o PodsMetricStatusPatchOutput) ToPodsMetricStatusPatchPtrOutputWithContext }).(PodsMetricStatusPatchPtrOutput) } +func (o PodsMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatusPatch] { + return pulumix.Output[PodsMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // currentAverageValue is the current value of the average of the metric across all relevant pods (as a quantity) func (o PodsMetricStatusPatchOutput) CurrentAverageValue() pulumi.StringPtrOutput { return o.ApplyT(func(v PodsMetricStatusPatch) *string { return v.CurrentAverageValue }).(pulumi.StringPtrOutput) @@ -5509,6 +6224,12 @@ func (o PodsMetricStatusPatchPtrOutput) ToPodsMetricStatusPatchPtrOutputWithCont return o } +func (o PodsMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatusPatch] { + return pulumix.Output[*PodsMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricStatusPatchPtrOutput) Elem() PodsMetricStatusPatchOutput { return o.ApplyT(func(v *PodsMetricStatusPatch) PodsMetricStatusPatch { if v != nil { @@ -5592,6 +6313,12 @@ func (i ResourceMetricSourceArgs) ToResourceMetricSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourceOutput) } +func (i ResourceMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSource] { + return pulumix.Output[ResourceMetricSource]{ + OutputState: i.ToResourceMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricSourceArgs) ToResourceMetricSourcePtrOutput() ResourceMetricSourcePtrOutput { return i.ToResourceMetricSourcePtrOutputWithContext(context.Background()) } @@ -5633,6 +6360,12 @@ func (i *resourceMetricSourcePtrType) ToResourceMetricSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePtrOutput) } +func (i *resourceMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSource] { + return pulumix.Output[*ResourceMetricSource]{ + OutputState: i.ToResourceMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ResourceMetricSourceOutput struct{ *pulumi.OutputState } @@ -5658,6 +6391,12 @@ func (o ResourceMetricSourceOutput) ToResourceMetricSourcePtrOutputWithContext(c }).(ResourceMetricSourcePtrOutput) } +func (o ResourceMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSource] { + return pulumix.Output[ResourceMetricSource]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource in question. func (o ResourceMetricSourceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ResourceMetricSource) string { return v.Name }).(pulumi.StringOutput) @@ -5687,6 +6426,12 @@ func (o ResourceMetricSourcePtrOutput) ToResourceMetricSourcePtrOutputWithContex return o } +func (o ResourceMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSource] { + return pulumix.Output[*ResourceMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricSourcePtrOutput) Elem() ResourceMetricSourceOutput { return o.ApplyT(func(v *ResourceMetricSource) ResourceMetricSource { if v != nil { @@ -5770,6 +6515,12 @@ func (i ResourceMetricSourcePatchArgs) ToResourceMetricSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePatchOutput) } +func (i ResourceMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSourcePatch] { + return pulumix.Output[ResourceMetricSourcePatch]{ + OutputState: i.ToResourceMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricSourcePatchArgs) ToResourceMetricSourcePatchPtrOutput() ResourceMetricSourcePatchPtrOutput { return i.ToResourceMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -5811,6 +6562,12 @@ func (i *resourceMetricSourcePatchPtrType) ToResourceMetricSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePatchPtrOutput) } +func (i *resourceMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSourcePatch] { + return pulumix.Output[*ResourceMetricSourcePatch]{ + OutputState: i.ToResourceMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ResourceMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -5836,6 +6593,12 @@ func (o ResourceMetricSourcePatchOutput) ToResourceMetricSourcePatchPtrOutputWit }).(ResourceMetricSourcePatchPtrOutput) } +func (o ResourceMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSourcePatch] { + return pulumix.Output[ResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource in question. func (o ResourceMetricSourcePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceMetricSourcePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5865,6 +6628,12 @@ func (o ResourceMetricSourcePatchPtrOutput) ToResourceMetricSourcePatchPtrOutput return o } +func (o ResourceMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSourcePatch] { + return pulumix.Output[*ResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricSourcePatchPtrOutput) Elem() ResourceMetricSourcePatchOutput { return o.ApplyT(func(v *ResourceMetricSourcePatch) ResourceMetricSourcePatch { if v != nil { @@ -5948,6 +6717,12 @@ func (i ResourceMetricStatusArgs) ToResourceMetricStatusOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusOutput) } +func (i ResourceMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatus] { + return pulumix.Output[ResourceMetricStatus]{ + OutputState: i.ToResourceMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricStatusArgs) ToResourceMetricStatusPtrOutput() ResourceMetricStatusPtrOutput { return i.ToResourceMetricStatusPtrOutputWithContext(context.Background()) } @@ -5989,6 +6764,12 @@ func (i *resourceMetricStatusPtrType) ToResourceMetricStatusPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPtrOutput) } +func (i *resourceMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatus] { + return pulumix.Output[*ResourceMetricStatus]{ + OutputState: i.ToResourceMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ResourceMetricStatusOutput struct{ *pulumi.OutputState } @@ -6014,6 +6795,12 @@ func (o ResourceMetricStatusOutput) ToResourceMetricStatusPtrOutputWithContext(c }).(ResourceMetricStatusPtrOutput) } +func (o ResourceMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatus] { + return pulumix.Output[ResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + // currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. It will only be present if `targetAverageValue` was set in the corresponding metric specification. func (o ResourceMetricStatusOutput) CurrentAverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v ResourceMetricStatus) *int { return v.CurrentAverageUtilization }).(pulumi.IntPtrOutput) @@ -6043,6 +6830,12 @@ func (o ResourceMetricStatusPtrOutput) ToResourceMetricStatusPtrOutputWithContex return o } +func (o ResourceMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatus] { + return pulumix.Output[*ResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricStatusPtrOutput) Elem() ResourceMetricStatusOutput { return o.ApplyT(func(v *ResourceMetricStatus) ResourceMetricStatus { if v != nil { @@ -6126,6 +6919,12 @@ func (i ResourceMetricStatusPatchArgs) ToResourceMetricStatusPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPatchOutput) } +func (i ResourceMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatusPatch] { + return pulumix.Output[ResourceMetricStatusPatch]{ + OutputState: i.ToResourceMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricStatusPatchArgs) ToResourceMetricStatusPatchPtrOutput() ResourceMetricStatusPatchPtrOutput { return i.ToResourceMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -6167,6 +6966,12 @@ func (i *resourceMetricStatusPatchPtrType) ToResourceMetricStatusPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPatchPtrOutput) } +func (i *resourceMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatusPatch] { + return pulumix.Output[*ResourceMetricStatusPatch]{ + OutputState: i.ToResourceMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ResourceMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -6192,6 +6997,12 @@ func (o ResourceMetricStatusPatchOutput) ToResourceMetricStatusPatchPtrOutputWit }).(ResourceMetricStatusPatchPtrOutput) } +func (o ResourceMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatusPatch] { + return pulumix.Output[ResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. It will only be present if `targetAverageValue` was set in the corresponding metric specification. func (o ResourceMetricStatusPatchOutput) CurrentAverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v ResourceMetricStatusPatch) *int { return v.CurrentAverageUtilization }).(pulumi.IntPtrOutput) @@ -6221,6 +7032,12 @@ func (o ResourceMetricStatusPatchPtrOutput) ToResourceMetricStatusPatchPtrOutput return o } +func (o ResourceMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatusPatch] { + return pulumix.Output[*ResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricStatusPatchPtrOutput) Elem() ResourceMetricStatusPatchOutput { return o.ApplyT(func(v *ResourceMetricStatusPatch) ResourceMetricStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscaler.go b/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscaler.go index 2cb96375a2..7e4b81514d 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscaler.go +++ b/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscaler.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. @@ -127,6 +128,12 @@ func (i *HorizontalPodAutoscaler) ToHorizontalPodAutoscalerOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerOutput) } +func (i *HorizontalPodAutoscaler) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerArrayInput is an input type that accepts HorizontalPodAutoscalerArray and HorizontalPodAutoscalerArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerArrayInput` via: // @@ -152,6 +159,12 @@ func (i HorizontalPodAutoscalerArray) ToHorizontalPodAutoscalerArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerArrayOutput) } +func (i HorizontalPodAutoscalerArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerMapInput is an input type that accepts HorizontalPodAutoscalerMap and HorizontalPodAutoscalerMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerMapInput` via: // @@ -177,6 +190,12 @@ func (i HorizontalPodAutoscalerMap) ToHorizontalPodAutoscalerMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerMapOutput) } +func (i HorizontalPodAutoscalerMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: i.ToHorizontalPodAutoscalerMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o HorizontalPodAutoscalerOutput) ToHorizontalPodAutoscalerOutputWithContex return o } +func (o HorizontalPodAutoscalerOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscaler] { + return pulumix.Output[*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscaler) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o HorizontalPodAutoscalerArrayOutput) ToHorizontalPodAutoscalerArrayOutput return o } +func (o HorizontalPodAutoscalerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscaler] { + return pulumix.Output[[]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].([]*HorizontalPodAutoscaler)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o HorizontalPodAutoscalerMapOutput) ToHorizontalPodAutoscalerMapOutputWith return o } +func (o HorizontalPodAutoscalerMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscaler] { + return pulumix.Output[map[string]*HorizontalPodAutoscaler]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscaler { return vs[0].(map[string]*HorizontalPodAutoscaler)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerList.go b/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerList.go index ad2921c024..40e4ef7018 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerList.go +++ b/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. @@ -117,6 +118,12 @@ func (i *HorizontalPodAutoscalerList) ToHorizontalPodAutoscalerListOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListOutput) } +func (i *HorizontalPodAutoscalerList) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListArrayInput is an input type that accepts HorizontalPodAutoscalerListArray and HorizontalPodAutoscalerListArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListArrayInput` via: // @@ -142,6 +149,12 @@ func (i HorizontalPodAutoscalerListArray) ToHorizontalPodAutoscalerListArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListArrayOutput) } +func (i HorizontalPodAutoscalerListArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerListMapInput is an input type that accepts HorizontalPodAutoscalerListMap and HorizontalPodAutoscalerListMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerListMapInput` via: // @@ -167,6 +180,12 @@ func (i HorizontalPodAutoscalerListMap) ToHorizontalPodAutoscalerListMapOutputWi return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListMapOutput) } +func (i HorizontalPodAutoscalerListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: i.ToHorizontalPodAutoscalerListMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerListOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o HorizontalPodAutoscalerListOutput) ToHorizontalPodAutoscalerListOutputWi return o } +func (o HorizontalPodAutoscalerListOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerList] { + return pulumix.Output[*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o HorizontalPodAutoscalerListArrayOutput) ToHorizontalPodAutoscalerListArr return o } +func (o HorizontalPodAutoscalerListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerList] { + return pulumix.Output[[]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].([]*HorizontalPodAutoscalerList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o HorizontalPodAutoscalerListMapOutput) ToHorizontalPodAutoscalerListMapOu return o } +func (o HorizontalPodAutoscalerListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerList] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerList]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerListMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerList { return vs[0].(map[string]*HorizontalPodAutoscalerList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerPatch.go b/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerPatch.go index 4eb19114a3..8310542f41 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerPatch.go +++ b/sdk/go/kubernetes/autoscaling/v2beta2/horizontalPodAutoscalerPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *HorizontalPodAutoscalerPatch) ToHorizontalPodAutoscalerPatchOutputWithC return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchOutput) } +func (i *HorizontalPodAutoscalerPatch) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchArrayInput is an input type that accepts HorizontalPodAutoscalerPatchArray and HorizontalPodAutoscalerPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i HorizontalPodAutoscalerPatchArray) ToHorizontalPodAutoscalerPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchArrayOutput) } +func (i HorizontalPodAutoscalerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerPatchMapInput is an input type that accepts HorizontalPodAutoscalerPatchMap and HorizontalPodAutoscalerPatchMapOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i HorizontalPodAutoscalerPatchMap) ToHorizontalPodAutoscalerPatchMapOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchMapOutput) } +func (i HorizontalPodAutoscalerPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: i.ToHorizontalPodAutoscalerPatchMapOutputWithContext(ctx).OutputState, + } +} + type HorizontalPodAutoscalerPatchOutput struct{ *pulumi.OutputState } func (HorizontalPodAutoscalerPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o HorizontalPodAutoscalerPatchOutput) ToHorizontalPodAutoscalerPatchOutput return o } +func (o HorizontalPodAutoscalerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerPatch] { + return pulumix.Output[*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o HorizontalPodAutoscalerPatchArrayOutput) ToHorizontalPodAutoscalerPatchA return o } +func (o HorizontalPodAutoscalerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[[]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].([]*HorizontalPodAutoscalerPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o HorizontalPodAutoscalerPatchMapOutput) ToHorizontalPodAutoscalerPatchMap return o } +func (o HorizontalPodAutoscalerPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*HorizontalPodAutoscalerPatch] { + return pulumix.Output[map[string]*HorizontalPodAutoscalerPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerPatchMapOutput) MapIndex(k pulumi.StringInput) HorizontalPodAutoscalerPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HorizontalPodAutoscalerPatch { return vs[0].(map[string]*HorizontalPodAutoscalerPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/autoscaling/v2beta2/pulumiTypes.go b/sdk/go/kubernetes/autoscaling/v2beta2/pulumiTypes.go index 36c021c7cf..e71dc9d0e2 100644 --- a/sdk/go/kubernetes/autoscaling/v2beta2/pulumiTypes.go +++ b/sdk/go/kubernetes/autoscaling/v2beta2/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -57,6 +58,12 @@ func (i ContainerResourceMetricSourceArgs) ToContainerResourceMetricSourceOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourceOutput) } +func (i ContainerResourceMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSource] { + return pulumix.Output[ContainerResourceMetricSource]{ + OutputState: i.ToContainerResourceMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricSourceArgs) ToContainerResourceMetricSourcePtrOutput() ContainerResourceMetricSourcePtrOutput { return i.ToContainerResourceMetricSourcePtrOutputWithContext(context.Background()) } @@ -98,6 +105,12 @@ func (i *containerResourceMetricSourcePtrType) ToContainerResourceMetricSourcePt return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePtrOutput) } +func (i *containerResourceMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSource] { + return pulumix.Output[*ContainerResourceMetricSource]{ + OutputState: i.ToContainerResourceMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ContainerResourceMetricSourceOutput struct{ *pulumi.OutputState } @@ -123,6 +136,12 @@ func (o ContainerResourceMetricSourceOutput) ToContainerResourceMetricSourcePtrO }).(ContainerResourceMetricSourcePtrOutput) } +func (o ContainerResourceMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSource] { + return pulumix.Output[ContainerResourceMetricSource]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricSourceOutput) Container() pulumi.StringOutput { return o.ApplyT(func(v ContainerResourceMetricSource) string { return v.Container }).(pulumi.StringOutput) @@ -152,6 +171,12 @@ func (o ContainerResourceMetricSourcePtrOutput) ToContainerResourceMetricSourceP return o } +func (o ContainerResourceMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSource] { + return pulumix.Output[*ContainerResourceMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricSourcePtrOutput) Elem() ContainerResourceMetricSourceOutput { return o.ApplyT(func(v *ContainerResourceMetricSource) ContainerResourceMetricSource { if v != nil { @@ -235,6 +260,12 @@ func (i ContainerResourceMetricSourcePatchArgs) ToContainerResourceMetricSourceP return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePatchOutput) } +func (i ContainerResourceMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSourcePatch] { + return pulumix.Output[ContainerResourceMetricSourcePatch]{ + OutputState: i.ToContainerResourceMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricSourcePatchArgs) ToContainerResourceMetricSourcePatchPtrOutput() ContainerResourceMetricSourcePatchPtrOutput { return i.ToContainerResourceMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -276,6 +307,12 @@ func (i *containerResourceMetricSourcePatchPtrType) ToContainerResourceMetricSou return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricSourcePatchPtrOutput) } +func (i *containerResourceMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSourcePatch] { + return pulumix.Output[*ContainerResourceMetricSourcePatch]{ + OutputState: i.ToContainerResourceMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ContainerResourceMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -301,6 +338,12 @@ func (o ContainerResourceMetricSourcePatchOutput) ToContainerResourceMetricSourc }).(ContainerResourceMetricSourcePatchPtrOutput) } +func (o ContainerResourceMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricSourcePatch] { + return pulumix.Output[ContainerResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricSourcePatchOutput) Container() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResourceMetricSourcePatch) *string { return v.Container }).(pulumi.StringPtrOutput) @@ -330,6 +373,12 @@ func (o ContainerResourceMetricSourcePatchPtrOutput) ToContainerResourceMetricSo return o } +func (o ContainerResourceMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricSourcePatch] { + return pulumix.Output[*ContainerResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricSourcePatchPtrOutput) Elem() ContainerResourceMetricSourcePatchOutput { return o.ApplyT(func(v *ContainerResourceMetricSourcePatch) ContainerResourceMetricSourcePatch { if v != nil { @@ -413,6 +462,12 @@ func (i ContainerResourceMetricStatusArgs) ToContainerResourceMetricStatusOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusOutput) } +func (i ContainerResourceMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatus] { + return pulumix.Output[ContainerResourceMetricStatus]{ + OutputState: i.ToContainerResourceMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricStatusArgs) ToContainerResourceMetricStatusPtrOutput() ContainerResourceMetricStatusPtrOutput { return i.ToContainerResourceMetricStatusPtrOutputWithContext(context.Background()) } @@ -454,6 +509,12 @@ func (i *containerResourceMetricStatusPtrType) ToContainerResourceMetricStatusPt return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPtrOutput) } +func (i *containerResourceMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatus] { + return pulumix.Output[*ContainerResourceMetricStatus]{ + OutputState: i.ToContainerResourceMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ContainerResourceMetricStatusOutput struct{ *pulumi.OutputState } @@ -479,6 +540,12 @@ func (o ContainerResourceMetricStatusOutput) ToContainerResourceMetricStatusPtrO }).(ContainerResourceMetricStatusPtrOutput) } +func (o ContainerResourceMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatus] { + return pulumix.Output[ContainerResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + // Container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricStatusOutput) Container() pulumi.StringOutput { return o.ApplyT(func(v ContainerResourceMetricStatus) string { return v.Container }).(pulumi.StringOutput) @@ -508,6 +575,12 @@ func (o ContainerResourceMetricStatusPtrOutput) ToContainerResourceMetricStatusP return o } +func (o ContainerResourceMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatus] { + return pulumix.Output[*ContainerResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricStatusPtrOutput) Elem() ContainerResourceMetricStatusOutput { return o.ApplyT(func(v *ContainerResourceMetricStatus) ContainerResourceMetricStatus { if v != nil { @@ -591,6 +664,12 @@ func (i ContainerResourceMetricStatusPatchArgs) ToContainerResourceMetricStatusP return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPatchOutput) } +func (i ContainerResourceMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatusPatch] { + return pulumix.Output[ContainerResourceMetricStatusPatch]{ + OutputState: i.ToContainerResourceMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerResourceMetricStatusPatchArgs) ToContainerResourceMetricStatusPatchPtrOutput() ContainerResourceMetricStatusPatchPtrOutput { return i.ToContainerResourceMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -632,6 +711,12 @@ func (i *containerResourceMetricStatusPatchPtrType) ToContainerResourceMetricSta return pulumi.ToOutputWithContext(ctx, i).(ContainerResourceMetricStatusPatchPtrOutput) } +func (i *containerResourceMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatusPatch] { + return pulumix.Output[*ContainerResourceMetricStatusPatch]{ + OutputState: i.ToContainerResourceMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ContainerResourceMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -657,6 +742,12 @@ func (o ContainerResourceMetricStatusPatchOutput) ToContainerResourceMetricStatu }).(ContainerResourceMetricStatusPatchPtrOutput) } +func (o ContainerResourceMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResourceMetricStatusPatch] { + return pulumix.Output[ContainerResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // Container is the name of the container in the pods of the scaling target func (o ContainerResourceMetricStatusPatchOutput) Container() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResourceMetricStatusPatch) *string { return v.Container }).(pulumi.StringPtrOutput) @@ -686,6 +777,12 @@ func (o ContainerResourceMetricStatusPatchPtrOutput) ToContainerResourceMetricSt return o } +func (o ContainerResourceMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerResourceMetricStatusPatch] { + return pulumix.Output[*ContainerResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResourceMetricStatusPatchPtrOutput) Elem() ContainerResourceMetricStatusPatchOutput { return o.ApplyT(func(v *ContainerResourceMetricStatusPatch) ContainerResourceMetricStatusPatch { if v != nil { @@ -769,6 +866,12 @@ func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferenceOutputWith return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferenceOutput) } +func (i CrossVersionObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferenceArgs) ToCrossVersionObjectReferencePtrOutput() CrossVersionObjectReferencePtrOutput { return i.ToCrossVersionObjectReferencePtrOutputWithContext(context.Background()) } @@ -810,6 +913,12 @@ func (i *crossVersionObjectReferencePtrType) ToCrossVersionObjectReferencePtrOut return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePtrOutput) } +func (i *crossVersionObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: i.ToCrossVersionObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferenceOutput struct{ *pulumi.OutputState } @@ -835,6 +944,12 @@ func (o CrossVersionObjectReferenceOutput) ToCrossVersionObjectReferencePtrOutpu }).(CrossVersionObjectReferencePtrOutput) } +func (o CrossVersionObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReference] { + return pulumix.Output[CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + // API version of the referent func (o CrossVersionObjectReferenceOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReference) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -864,6 +979,12 @@ func (o CrossVersionObjectReferencePtrOutput) ToCrossVersionObjectReferencePtrOu return o } +func (o CrossVersionObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReference] { + return pulumix.Output[*CrossVersionObjectReference]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePtrOutput) Elem() CrossVersionObjectReferenceOutput { return o.ApplyT(func(v *CrossVersionObjectReference) CrossVersionObjectReference { if v != nil { @@ -947,6 +1068,12 @@ func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatch return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchOutput) } +func (i CrossVersionObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i CrossVersionObjectReferencePatchArgs) ToCrossVersionObjectReferencePatchPtrOutput() CrossVersionObjectReferencePatchPtrOutput { return i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -988,6 +1115,12 @@ func (i *crossVersionObjectReferencePatchPtrType) ToCrossVersionObjectReferenceP return pulumi.ToOutputWithContext(ctx, i).(CrossVersionObjectReferencePatchPtrOutput) } +func (i *crossVersionObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: i.ToCrossVersionObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // CrossVersionObjectReference contains enough information to let you identify the referred resource. type CrossVersionObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -1013,6 +1146,12 @@ func (o CrossVersionObjectReferencePatchOutput) ToCrossVersionObjectReferencePat }).(CrossVersionObjectReferencePatchPtrOutput) } +func (o CrossVersionObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CrossVersionObjectReferencePatch] { + return pulumix.Output[CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // API version of the referent func (o CrossVersionObjectReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CrossVersionObjectReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1042,6 +1181,12 @@ func (o CrossVersionObjectReferencePatchPtrOutput) ToCrossVersionObjectReference return o } +func (o CrossVersionObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CrossVersionObjectReferencePatch] { + return pulumix.Output[*CrossVersionObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o CrossVersionObjectReferencePatchPtrOutput) Elem() CrossVersionObjectReferencePatchOutput { return o.ApplyT(func(v *CrossVersionObjectReferencePatch) CrossVersionObjectReferencePatch { if v != nil { @@ -1121,6 +1266,12 @@ func (i ExternalMetricSourceArgs) ToExternalMetricSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourceOutput) } +func (i ExternalMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSource] { + return pulumix.Output[ExternalMetricSource]{ + OutputState: i.ToExternalMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricSourceArgs) ToExternalMetricSourcePtrOutput() ExternalMetricSourcePtrOutput { return i.ToExternalMetricSourcePtrOutputWithContext(context.Background()) } @@ -1162,6 +1313,12 @@ func (i *externalMetricSourcePtrType) ToExternalMetricSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePtrOutput) } +func (i *externalMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSource] { + return pulumix.Output[*ExternalMetricSource]{ + OutputState: i.ToExternalMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). type ExternalMetricSourceOutput struct{ *pulumi.OutputState } @@ -1187,6 +1344,12 @@ func (o ExternalMetricSourceOutput) ToExternalMetricSourcePtrOutputWithContext(c }).(ExternalMetricSourcePtrOutput) } +func (o ExternalMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSource] { + return pulumix.Output[ExternalMetricSource]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o ExternalMetricSourceOutput) Metric() MetricIdentifierOutput { return o.ApplyT(func(v ExternalMetricSource) MetricIdentifier { return v.Metric }).(MetricIdentifierOutput) @@ -1211,6 +1374,12 @@ func (o ExternalMetricSourcePtrOutput) ToExternalMetricSourcePtrOutputWithContex return o } +func (o ExternalMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSource] { + return pulumix.Output[*ExternalMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricSourcePtrOutput) Elem() ExternalMetricSourceOutput { return o.ApplyT(func(v *ExternalMetricSource) ExternalMetricSource { if v != nil { @@ -1280,6 +1449,12 @@ func (i ExternalMetricSourcePatchArgs) ToExternalMetricSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePatchOutput) } +func (i ExternalMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSourcePatch] { + return pulumix.Output[ExternalMetricSourcePatch]{ + OutputState: i.ToExternalMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricSourcePatchArgs) ToExternalMetricSourcePatchPtrOutput() ExternalMetricSourcePatchPtrOutput { return i.ToExternalMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -1321,6 +1496,12 @@ func (i *externalMetricSourcePatchPtrType) ToExternalMetricSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricSourcePatchPtrOutput) } +func (i *externalMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSourcePatch] { + return pulumix.Output[*ExternalMetricSourcePatch]{ + OutputState: i.ToExternalMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). type ExternalMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -1346,6 +1527,12 @@ func (o ExternalMetricSourcePatchOutput) ToExternalMetricSourcePatchPtrOutputWit }).(ExternalMetricSourcePatchPtrOutput) } +func (o ExternalMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricSourcePatch] { + return pulumix.Output[ExternalMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o ExternalMetricSourcePatchOutput) Metric() MetricIdentifierPatchPtrOutput { return o.ApplyT(func(v ExternalMetricSourcePatch) *MetricIdentifierPatch { return v.Metric }).(MetricIdentifierPatchPtrOutput) @@ -1370,6 +1557,12 @@ func (o ExternalMetricSourcePatchPtrOutput) ToExternalMetricSourcePatchPtrOutput return o } +func (o ExternalMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricSourcePatch] { + return pulumix.Output[*ExternalMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricSourcePatchPtrOutput) Elem() ExternalMetricSourcePatchOutput { return o.ApplyT(func(v *ExternalMetricSourcePatch) ExternalMetricSourcePatch { if v != nil { @@ -1439,6 +1632,12 @@ func (i ExternalMetricStatusArgs) ToExternalMetricStatusOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusOutput) } +func (i ExternalMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatus] { + return pulumix.Output[ExternalMetricStatus]{ + OutputState: i.ToExternalMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricStatusArgs) ToExternalMetricStatusPtrOutput() ExternalMetricStatusPtrOutput { return i.ToExternalMetricStatusPtrOutputWithContext(context.Background()) } @@ -1480,6 +1679,12 @@ func (i *externalMetricStatusPtrType) ToExternalMetricStatusPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPtrOutput) } +func (i *externalMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatus] { + return pulumix.Output[*ExternalMetricStatus]{ + OutputState: i.ToExternalMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. type ExternalMetricStatusOutput struct{ *pulumi.OutputState } @@ -1505,6 +1710,12 @@ func (o ExternalMetricStatusOutput) ToExternalMetricStatusPtrOutputWithContext(c }).(ExternalMetricStatusPtrOutput) } +func (o ExternalMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatus] { + return pulumix.Output[ExternalMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ExternalMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v ExternalMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -1529,6 +1740,12 @@ func (o ExternalMetricStatusPtrOutput) ToExternalMetricStatusPtrOutputWithContex return o } +func (o ExternalMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatus] { + return pulumix.Output[*ExternalMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricStatusPtrOutput) Elem() ExternalMetricStatusOutput { return o.ApplyT(func(v *ExternalMetricStatus) ExternalMetricStatus { if v != nil { @@ -1598,6 +1815,12 @@ func (i ExternalMetricStatusPatchArgs) ToExternalMetricStatusPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPatchOutput) } +func (i ExternalMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatusPatch] { + return pulumix.Output[ExternalMetricStatusPatch]{ + OutputState: i.ToExternalMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExternalMetricStatusPatchArgs) ToExternalMetricStatusPatchPtrOutput() ExternalMetricStatusPatchPtrOutput { return i.ToExternalMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -1639,6 +1862,12 @@ func (i *externalMetricStatusPatchPtrType) ToExternalMetricStatusPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ExternalMetricStatusPatchPtrOutput) } +func (i *externalMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatusPatch] { + return pulumix.Output[*ExternalMetricStatusPatch]{ + OutputState: i.ToExternalMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. type ExternalMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -1664,6 +1893,12 @@ func (o ExternalMetricStatusPatchOutput) ToExternalMetricStatusPatchPtrOutputWit }).(ExternalMetricStatusPatchPtrOutput) } +func (o ExternalMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExternalMetricStatusPatch] { + return pulumix.Output[ExternalMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ExternalMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v ExternalMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -1688,6 +1923,12 @@ func (o ExternalMetricStatusPatchPtrOutput) ToExternalMetricStatusPatchPtrOutput return o } +func (o ExternalMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExternalMetricStatusPatch] { + return pulumix.Output[*ExternalMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ExternalMetricStatusPatchPtrOutput) Elem() ExternalMetricStatusPatchOutput { return o.ApplyT(func(v *ExternalMetricStatusPatch) ExternalMetricStatusPatch { if v != nil { @@ -1761,6 +2002,12 @@ func (i HPAScalingPolicyArgs) ToHPAScalingPolicyOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyOutput) } +func (i HPAScalingPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicy] { + return pulumix.Output[HPAScalingPolicy]{ + OutputState: i.ToHPAScalingPolicyOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicyArrayInput is an input type that accepts HPAScalingPolicyArray and HPAScalingPolicyArrayOutput values. // You can construct a concrete instance of `HPAScalingPolicyArrayInput` via: // @@ -1786,6 +2033,12 @@ func (i HPAScalingPolicyArray) ToHPAScalingPolicyArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyArrayOutput) } +func (i HPAScalingPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicy] { + return pulumix.Output[[]HPAScalingPolicy]{ + OutputState: i.ToHPAScalingPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicy is a single policy which must hold true for a specified past interval. type HPAScalingPolicyOutput struct{ *pulumi.OutputState } @@ -1801,6 +2054,12 @@ func (o HPAScalingPolicyOutput) ToHPAScalingPolicyOutputWithContext(ctx context. return o } +func (o HPAScalingPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicy] { + return pulumix.Output[HPAScalingPolicy]{ + OutputState: o.OutputState, + } +} + // PeriodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). func (o HPAScalingPolicyOutput) PeriodSeconds() pulumi.IntOutput { return o.ApplyT(func(v HPAScalingPolicy) int { return v.PeriodSeconds }).(pulumi.IntOutput) @@ -1830,6 +2089,12 @@ func (o HPAScalingPolicyArrayOutput) ToHPAScalingPolicyArrayOutputWithContext(ct return o } +func (o HPAScalingPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicy] { + return pulumix.Output[[]HPAScalingPolicy]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingPolicyArrayOutput) Index(i pulumi.IntInput) HPAScalingPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HPAScalingPolicy { return vs[0].([]HPAScalingPolicy)[vs[1].(int)] @@ -1879,6 +2144,12 @@ func (i HPAScalingPolicyPatchArgs) ToHPAScalingPolicyPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyPatchOutput) } +func (i HPAScalingPolicyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicyPatch] { + return pulumix.Output[HPAScalingPolicyPatch]{ + OutputState: i.ToHPAScalingPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicyPatchArrayInput is an input type that accepts HPAScalingPolicyPatchArray and HPAScalingPolicyPatchArrayOutput values. // You can construct a concrete instance of `HPAScalingPolicyPatchArrayInput` via: // @@ -1904,6 +2175,12 @@ func (i HPAScalingPolicyPatchArray) ToHPAScalingPolicyPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(HPAScalingPolicyPatchArrayOutput) } +func (i HPAScalingPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicyPatch] { + return pulumix.Output[[]HPAScalingPolicyPatch]{ + OutputState: i.ToHPAScalingPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HPAScalingPolicy is a single policy which must hold true for a specified past interval. type HPAScalingPolicyPatchOutput struct{ *pulumi.OutputState } @@ -1919,6 +2196,12 @@ func (o HPAScalingPolicyPatchOutput) ToHPAScalingPolicyPatchOutputWithContext(ct return o } +func (o HPAScalingPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingPolicyPatch] { + return pulumix.Output[HPAScalingPolicyPatch]{ + OutputState: o.OutputState, + } +} + // PeriodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). func (o HPAScalingPolicyPatchOutput) PeriodSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v HPAScalingPolicyPatch) *int { return v.PeriodSeconds }).(pulumi.IntPtrOutput) @@ -1948,6 +2231,12 @@ func (o HPAScalingPolicyPatchArrayOutput) ToHPAScalingPolicyPatchArrayOutputWith return o } +func (o HPAScalingPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HPAScalingPolicyPatch] { + return pulumix.Output[[]HPAScalingPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingPolicyPatchArrayOutput) Index(i pulumi.IntInput) HPAScalingPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HPAScalingPolicyPatch { return vs[0].([]HPAScalingPolicyPatch)[vs[1].(int)] @@ -1997,6 +2286,12 @@ func (i HPAScalingRulesArgs) ToHPAScalingRulesOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesOutput) } +func (i HPAScalingRulesArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRules] { + return pulumix.Output[HPAScalingRules]{ + OutputState: i.ToHPAScalingRulesOutputWithContext(ctx).OutputState, + } +} + func (i HPAScalingRulesArgs) ToHPAScalingRulesPtrOutput() HPAScalingRulesPtrOutput { return i.ToHPAScalingRulesPtrOutputWithContext(context.Background()) } @@ -2038,6 +2333,12 @@ func (i *hpascalingRulesPtrType) ToHPAScalingRulesPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesPtrOutput) } +func (i *hpascalingRulesPtrType) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRules] { + return pulumix.Output[*HPAScalingRules]{ + OutputState: i.ToHPAScalingRulesPtrOutputWithContext(ctx).OutputState, + } +} + // HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen. type HPAScalingRulesOutput struct{ *pulumi.OutputState } @@ -2063,6 +2364,12 @@ func (o HPAScalingRulesOutput) ToHPAScalingRulesPtrOutputWithContext(ctx context }).(HPAScalingRulesPtrOutput) } +func (o HPAScalingRulesOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRules] { + return pulumix.Output[HPAScalingRules]{ + OutputState: o.OutputState, + } +} + // policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid func (o HPAScalingRulesOutput) Policies() HPAScalingPolicyArrayOutput { return o.ApplyT(func(v HPAScalingRules) []HPAScalingPolicy { return v.Policies }).(HPAScalingPolicyArrayOutput) @@ -2092,6 +2399,12 @@ func (o HPAScalingRulesPtrOutput) ToHPAScalingRulesPtrOutputWithContext(ctx cont return o } +func (o HPAScalingRulesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRules] { + return pulumix.Output[*HPAScalingRules]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingRulesPtrOutput) Elem() HPAScalingRulesOutput { return o.ApplyT(func(v *HPAScalingRules) HPAScalingRules { if v != nil { @@ -2175,6 +2488,12 @@ func (i HPAScalingRulesPatchArgs) ToHPAScalingRulesPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesPatchOutput) } +func (i HPAScalingRulesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRulesPatch] { + return pulumix.Output[HPAScalingRulesPatch]{ + OutputState: i.ToHPAScalingRulesPatchOutputWithContext(ctx).OutputState, + } +} + func (i HPAScalingRulesPatchArgs) ToHPAScalingRulesPatchPtrOutput() HPAScalingRulesPatchPtrOutput { return i.ToHPAScalingRulesPatchPtrOutputWithContext(context.Background()) } @@ -2216,6 +2535,12 @@ func (i *hpascalingRulesPatchPtrType) ToHPAScalingRulesPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(HPAScalingRulesPatchPtrOutput) } +func (i *hpascalingRulesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRulesPatch] { + return pulumix.Output[*HPAScalingRulesPatch]{ + OutputState: i.ToHPAScalingRulesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen. type HPAScalingRulesPatchOutput struct{ *pulumi.OutputState } @@ -2241,6 +2566,12 @@ func (o HPAScalingRulesPatchOutput) ToHPAScalingRulesPatchPtrOutputWithContext(c }).(HPAScalingRulesPatchPtrOutput) } +func (o HPAScalingRulesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HPAScalingRulesPatch] { + return pulumix.Output[HPAScalingRulesPatch]{ + OutputState: o.OutputState, + } +} + // policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid func (o HPAScalingRulesPatchOutput) Policies() HPAScalingPolicyPatchArrayOutput { return o.ApplyT(func(v HPAScalingRulesPatch) []HPAScalingPolicyPatch { return v.Policies }).(HPAScalingPolicyPatchArrayOutput) @@ -2270,6 +2601,12 @@ func (o HPAScalingRulesPatchPtrOutput) ToHPAScalingRulesPatchPtrOutputWithContex return o } +func (o HPAScalingRulesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HPAScalingRulesPatch] { + return pulumix.Output[*HPAScalingRulesPatch]{ + OutputState: o.OutputState, + } +} + func (o HPAScalingRulesPatchPtrOutput) Elem() HPAScalingRulesPatchOutput { return o.ApplyT(func(v *HPAScalingRulesPatch) HPAScalingRulesPatch { if v != nil { @@ -2361,6 +2698,12 @@ func (i HorizontalPodAutoscalerTypeArgs) ToHorizontalPodAutoscalerTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeOutput) } +func (i HorizontalPodAutoscalerTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerTypeArrayInput is an input type that accepts HorizontalPodAutoscalerTypeArray and HorizontalPodAutoscalerTypeArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerTypeArrayInput` via: // @@ -2386,6 +2729,12 @@ func (i HorizontalPodAutoscalerTypeArray) ToHorizontalPodAutoscalerTypeArrayOutp return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerTypeArrayOutput) } +func (i HorizontalPodAutoscalerTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: i.ToHorizontalPodAutoscalerTypeArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. type HorizontalPodAutoscalerTypeOutput struct{ *pulumi.OutputState } @@ -2401,6 +2750,12 @@ func (o HorizontalPodAutoscalerTypeOutput) ToHorizontalPodAutoscalerTypeOutputWi return o } +func (o HorizontalPodAutoscalerTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerType] { + return pulumix.Output[HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2440,6 +2795,12 @@ func (o HorizontalPodAutoscalerTypeArrayOutput) ToHorizontalPodAutoscalerTypeArr return o } +func (o HorizontalPodAutoscalerTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerType] { + return pulumix.Output[[]HorizontalPodAutoscalerType]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerTypeArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerType { return vs[0].([]HorizontalPodAutoscalerType)[vs[1].(int)] @@ -2491,6 +2852,12 @@ func (i HorizontalPodAutoscalerBehaviorArgs) ToHorizontalPodAutoscalerBehaviorOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorOutput) } +func (i HorizontalPodAutoscalerBehaviorArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehavior] { + return pulumix.Output[HorizontalPodAutoscalerBehavior]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerBehaviorArgs) ToHorizontalPodAutoscalerBehaviorPtrOutput() HorizontalPodAutoscalerBehaviorPtrOutput { return i.ToHorizontalPodAutoscalerBehaviorPtrOutputWithContext(context.Background()) } @@ -2532,6 +2899,12 @@ func (i *horizontalPodAutoscalerBehaviorPtrType) ToHorizontalPodAutoscalerBehavi return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorPtrOutput) } +func (i *horizontalPodAutoscalerBehaviorPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehavior] { + return pulumix.Output[*HorizontalPodAutoscalerBehavior]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). type HorizontalPodAutoscalerBehaviorOutput struct{ *pulumi.OutputState } @@ -2557,6 +2930,12 @@ func (o HorizontalPodAutoscalerBehaviorOutput) ToHorizontalPodAutoscalerBehavior }).(HorizontalPodAutoscalerBehaviorPtrOutput) } +func (o HorizontalPodAutoscalerBehaviorOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehavior] { + return pulumix.Output[HorizontalPodAutoscalerBehavior]{ + OutputState: o.OutputState, + } +} + // scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used). func (o HorizontalPodAutoscalerBehaviorOutput) ScaleDown() HPAScalingRulesPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerBehavior) *HPAScalingRules { return v.ScaleDown }).(HPAScalingRulesPtrOutput) @@ -2584,6 +2963,12 @@ func (o HorizontalPodAutoscalerBehaviorPtrOutput) ToHorizontalPodAutoscalerBehav return o } +func (o HorizontalPodAutoscalerBehaviorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehavior] { + return pulumix.Output[*HorizontalPodAutoscalerBehavior]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerBehaviorPtrOutput) Elem() HorizontalPodAutoscalerBehaviorOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerBehavior) HorizontalPodAutoscalerBehavior { if v != nil { @@ -2662,6 +3047,12 @@ func (i HorizontalPodAutoscalerBehaviorPatchArgs) ToHorizontalPodAutoscalerBehav return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorPatchOutput) } +func (i HorizontalPodAutoscalerBehaviorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerBehaviorPatchArgs) ToHorizontalPodAutoscalerBehaviorPatchPtrOutput() HorizontalPodAutoscalerBehaviorPatchPtrOutput { return i.ToHorizontalPodAutoscalerBehaviorPatchPtrOutputWithContext(context.Background()) } @@ -2703,6 +3094,12 @@ func (i *horizontalPodAutoscalerBehaviorPatchPtrType) ToHorizontalPodAutoscalerB return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerBehaviorPatchPtrOutput) } +func (i *horizontalPodAutoscalerBehaviorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: i.ToHorizontalPodAutoscalerBehaviorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). type HorizontalPodAutoscalerBehaviorPatchOutput struct{ *pulumi.OutputState } @@ -2728,6 +3125,12 @@ func (o HorizontalPodAutoscalerBehaviorPatchOutput) ToHorizontalPodAutoscalerBeh }).(HorizontalPodAutoscalerBehaviorPatchPtrOutput) } +func (o HorizontalPodAutoscalerBehaviorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: o.OutputState, + } +} + // scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used). func (o HorizontalPodAutoscalerBehaviorPatchOutput) ScaleDown() HPAScalingRulesPatchPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerBehaviorPatch) *HPAScalingRulesPatch { return v.ScaleDown }).(HPAScalingRulesPatchPtrOutput) @@ -2755,6 +3158,12 @@ func (o HorizontalPodAutoscalerBehaviorPatchPtrOutput) ToHorizontalPodAutoscaler return o } +func (o HorizontalPodAutoscalerBehaviorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch] { + return pulumix.Output[*HorizontalPodAutoscalerBehaviorPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerBehaviorPatchPtrOutput) Elem() HorizontalPodAutoscalerBehaviorPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerBehaviorPatch) HorizontalPodAutoscalerBehaviorPatch { if v != nil { @@ -2839,6 +3248,12 @@ func (i HorizontalPodAutoscalerConditionArgs) ToHorizontalPodAutoscalerCondition return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionOutput) } +func (i HorizontalPodAutoscalerConditionArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerCondition] { + return pulumix.Output[HorizontalPodAutoscalerCondition]{ + OutputState: i.ToHorizontalPodAutoscalerConditionOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerConditionArrayInput is an input type that accepts HorizontalPodAutoscalerConditionArray and HorizontalPodAutoscalerConditionArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerConditionArrayInput` via: // @@ -2864,6 +3279,12 @@ func (i HorizontalPodAutoscalerConditionArray) ToHorizontalPodAutoscalerConditio return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionArrayOutput) } +func (i HorizontalPodAutoscalerConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerCondition] { + return pulumix.Output[[]HorizontalPodAutoscalerCondition]{ + OutputState: i.ToHorizontalPodAutoscalerConditionArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. type HorizontalPodAutoscalerConditionOutput struct{ *pulumi.OutputState } @@ -2879,6 +3300,12 @@ func (o HorizontalPodAutoscalerConditionOutput) ToHorizontalPodAutoscalerConditi return o } +func (o HorizontalPodAutoscalerConditionOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerCondition] { + return pulumix.Output[HorizontalPodAutoscalerCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another func (o HorizontalPodAutoscalerConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2918,6 +3345,12 @@ func (o HorizontalPodAutoscalerConditionArrayOutput) ToHorizontalPodAutoscalerCo return o } +func (o HorizontalPodAutoscalerConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerCondition] { + return pulumix.Output[[]HorizontalPodAutoscalerCondition]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerConditionArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerCondition { return vs[0].([]HorizontalPodAutoscalerCondition)[vs[1].(int)] @@ -2975,6 +3408,12 @@ func (i HorizontalPodAutoscalerConditionPatchArgs) ToHorizontalPodAutoscalerCond return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionPatchOutput) } +func (i HorizontalPodAutoscalerConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[HorizontalPodAutoscalerConditionPatch]{ + OutputState: i.ToHorizontalPodAutoscalerConditionPatchOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerConditionPatchArrayInput is an input type that accepts HorizontalPodAutoscalerConditionPatchArray and HorizontalPodAutoscalerConditionPatchArrayOutput values. // You can construct a concrete instance of `HorizontalPodAutoscalerConditionPatchArrayInput` via: // @@ -3000,6 +3439,12 @@ func (i HorizontalPodAutoscalerConditionPatchArray) ToHorizontalPodAutoscalerCon return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerConditionPatchArrayOutput) } +func (i HorizontalPodAutoscalerConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[[]HorizontalPodAutoscalerConditionPatch]{ + OutputState: i.ToHorizontalPodAutoscalerConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. type HorizontalPodAutoscalerConditionPatchOutput struct{ *pulumi.OutputState } @@ -3015,6 +3460,12 @@ func (o HorizontalPodAutoscalerConditionPatchOutput) ToHorizontalPodAutoscalerCo return o } +func (o HorizontalPodAutoscalerConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[HorizontalPodAutoscalerConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another func (o HorizontalPodAutoscalerConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3054,6 +3505,12 @@ func (o HorizontalPodAutoscalerConditionPatchArrayOutput) ToHorizontalPodAutosca return o } +func (o HorizontalPodAutoscalerConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HorizontalPodAutoscalerConditionPatch] { + return pulumix.Output[[]HorizontalPodAutoscalerConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerConditionPatchArrayOutput) Index(i pulumi.IntInput) HorizontalPodAutoscalerConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HorizontalPodAutoscalerConditionPatch { return vs[0].([]HorizontalPodAutoscalerConditionPatch)[vs[1].(int)] @@ -3107,6 +3564,12 @@ func (i HorizontalPodAutoscalerListTypeArgs) ToHorizontalPodAutoscalerListTypeOu return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerListTypeOutput) } +func (i HorizontalPodAutoscalerListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: i.ToHorizontalPodAutoscalerListTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. type HorizontalPodAutoscalerListTypeOutput struct{ *pulumi.OutputState } @@ -3122,6 +3585,12 @@ func (o HorizontalPodAutoscalerListTypeOutput) ToHorizontalPodAutoscalerListType return o } +func (o HorizontalPodAutoscalerListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerListType] { + return pulumix.Output[HorizontalPodAutoscalerListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3193,6 +3662,12 @@ func (i HorizontalPodAutoscalerPatchTypeArgs) ToHorizontalPodAutoscalerPatchType return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerPatchTypeOutput) } +func (i HorizontalPodAutoscalerPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: i.ToHorizontalPodAutoscalerPatchTypeOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. type HorizontalPodAutoscalerPatchTypeOutput struct{ *pulumi.OutputState } @@ -3208,6 +3683,12 @@ func (o HorizontalPodAutoscalerPatchTypeOutput) ToHorizontalPodAutoscalerPatchTy return o } +func (o HorizontalPodAutoscalerPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerPatchType] { + return pulumix.Output[HorizontalPodAutoscalerPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o HorizontalPodAutoscalerPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3284,6 +3765,12 @@ func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecOutputWith return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecOutput) } +func (i HorizontalPodAutoscalerSpecArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecArgs) ToHorizontalPodAutoscalerSpecPtrOutput() HorizontalPodAutoscalerSpecPtrOutput { return i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(context.Background()) } @@ -3325,6 +3812,12 @@ func (i *horizontalPodAutoscalerSpecPtrType) ToHorizontalPodAutoscalerSpecPtrOut return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPtrOutput) } +func (i *horizontalPodAutoscalerSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. type HorizontalPodAutoscalerSpecOutput struct{ *pulumi.OutputState } @@ -3350,6 +3843,12 @@ func (o HorizontalPodAutoscalerSpecOutput) ToHorizontalPodAutoscalerSpecPtrOutpu }).(HorizontalPodAutoscalerSpecPtrOutput) } +func (o HorizontalPodAutoscalerSpecOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpec] { + return pulumix.Output[HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + // behavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). If not set, the default HPAScalingRules for scale up and scale down are used. func (o HorizontalPodAutoscalerSpecOutput) Behavior() HorizontalPodAutoscalerBehaviorPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpec) *HorizontalPodAutoscalerBehavior { return v.Behavior }).(HorizontalPodAutoscalerBehaviorPtrOutput) @@ -3389,6 +3888,12 @@ func (o HorizontalPodAutoscalerSpecPtrOutput) ToHorizontalPodAutoscalerSpecPtrOu return o } +func (o HorizontalPodAutoscalerSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpec] { + return pulumix.Output[*HorizontalPodAutoscalerSpec]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPtrOutput) Elem() HorizontalPodAutoscalerSpecOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpec) HorizontalPodAutoscalerSpec { if v != nil { @@ -3500,6 +4005,12 @@ func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatch return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchOutput) } +func (i HorizontalPodAutoscalerSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerSpecPatchArgs) ToHorizontalPodAutoscalerSpecPatchPtrOutput() HorizontalPodAutoscalerSpecPatchPtrOutput { return i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(context.Background()) } @@ -3541,6 +4052,12 @@ func (i *horizontalPodAutoscalerSpecPatchPtrType) ToHorizontalPodAutoscalerSpecP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (i *horizontalPodAutoscalerSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: i.ToHorizontalPodAutoscalerSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. type HorizontalPodAutoscalerSpecPatchOutput struct{ *pulumi.OutputState } @@ -3566,6 +4083,12 @@ func (o HorizontalPodAutoscalerSpecPatchOutput) ToHorizontalPodAutoscalerSpecPat }).(HorizontalPodAutoscalerSpecPatchPtrOutput) } +func (o HorizontalPodAutoscalerSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + // behavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). If not set, the default HPAScalingRules for scale up and scale down are used. func (o HorizontalPodAutoscalerSpecPatchOutput) Behavior() HorizontalPodAutoscalerBehaviorPatchPtrOutput { return o.ApplyT(func(v HorizontalPodAutoscalerSpecPatch) *HorizontalPodAutoscalerBehaviorPatch { return v.Behavior }).(HorizontalPodAutoscalerBehaviorPatchPtrOutput) @@ -3605,6 +4128,12 @@ func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToHorizontalPodAutoscalerSpec return o } +func (o HorizontalPodAutoscalerSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerSpecPatch] { + return pulumix.Output[*HorizontalPodAutoscalerSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerSpecPatchPtrOutput) Elem() HorizontalPodAutoscalerSpecPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerSpecPatch) HorizontalPodAutoscalerSpecPatch { if v != nil { @@ -3720,6 +4249,12 @@ func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusOutput return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusOutput) } +func (i HorizontalPodAutoscalerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusArgs) ToHorizontalPodAutoscalerStatusPtrOutput() HorizontalPodAutoscalerStatusPtrOutput { return i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(context.Background()) } @@ -3761,6 +4296,12 @@ func (i *horizontalPodAutoscalerStatusPtrType) ToHorizontalPodAutoscalerStatusPt return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPtrOutput) } +func (i *horizontalPodAutoscalerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. type HorizontalPodAutoscalerStatusOutput struct{ *pulumi.OutputState } @@ -3786,6 +4327,12 @@ func (o HorizontalPodAutoscalerStatusOutput) ToHorizontalPodAutoscalerStatusPtrO }).(HorizontalPodAutoscalerStatusPtrOutput) } +func (o HorizontalPodAutoscalerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatus] { + return pulumix.Output[HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + // conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. func (o HorizontalPodAutoscalerStatusOutput) Conditions() HorizontalPodAutoscalerConditionArrayOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatus) []HorizontalPodAutoscalerCondition { return v.Conditions }).(HorizontalPodAutoscalerConditionArrayOutput) @@ -3830,6 +4377,12 @@ func (o HorizontalPodAutoscalerStatusPtrOutput) ToHorizontalPodAutoscalerStatusP return o } +func (o HorizontalPodAutoscalerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatus] { + return pulumix.Output[*HorizontalPodAutoscalerStatus]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPtrOutput) Elem() HorizontalPodAutoscalerStatusOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatus) HorizontalPodAutoscalerStatus { if v != nil { @@ -3955,6 +4508,12 @@ func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusP return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchOutput) } +func (i HorizontalPodAutoscalerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i HorizontalPodAutoscalerStatusPatchArgs) ToHorizontalPodAutoscalerStatusPatchPtrOutput() HorizontalPodAutoscalerStatusPatchPtrOutput { return i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(context.Background()) } @@ -3996,6 +4555,12 @@ func (i *horizontalPodAutoscalerStatusPatchPtrType) ToHorizontalPodAutoscalerSta return pulumi.ToOutputWithContext(ctx, i).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (i *horizontalPodAutoscalerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: i.ToHorizontalPodAutoscalerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. type HorizontalPodAutoscalerStatusPatchOutput struct{ *pulumi.OutputState } @@ -4021,6 +4586,12 @@ func (o HorizontalPodAutoscalerStatusPatchOutput) ToHorizontalPodAutoscalerStatu }).(HorizontalPodAutoscalerStatusPatchPtrOutput) } +func (o HorizontalPodAutoscalerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + // conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. func (o HorizontalPodAutoscalerStatusPatchOutput) Conditions() HorizontalPodAutoscalerConditionPatchArrayOutput { return o.ApplyT(func(v HorizontalPodAutoscalerStatusPatch) []HorizontalPodAutoscalerConditionPatch { @@ -4067,6 +4638,12 @@ func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToHorizontalPodAutoscalerSt return o } +func (o HorizontalPodAutoscalerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HorizontalPodAutoscalerStatusPatch] { + return pulumix.Output[*HorizontalPodAutoscalerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o HorizontalPodAutoscalerStatusPatchPtrOutput) Elem() HorizontalPodAutoscalerStatusPatchOutput { return o.ApplyT(func(v *HorizontalPodAutoscalerStatusPatch) HorizontalPodAutoscalerStatusPatch { if v != nil { @@ -4176,6 +4753,12 @@ func (i MetricIdentifierArgs) ToMetricIdentifierOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierOutput) } +func (i MetricIdentifierArgs) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifier] { + return pulumix.Output[MetricIdentifier]{ + OutputState: i.ToMetricIdentifierOutputWithContext(ctx).OutputState, + } +} + func (i MetricIdentifierArgs) ToMetricIdentifierPtrOutput() MetricIdentifierPtrOutput { return i.ToMetricIdentifierPtrOutputWithContext(context.Background()) } @@ -4217,6 +4800,12 @@ func (i *metricIdentifierPtrType) ToMetricIdentifierPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierPtrOutput) } +func (i *metricIdentifierPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifier] { + return pulumix.Output[*MetricIdentifier]{ + OutputState: i.ToMetricIdentifierPtrOutputWithContext(ctx).OutputState, + } +} + // MetricIdentifier defines the name and optionally selector for a metric type MetricIdentifierOutput struct{ *pulumi.OutputState } @@ -4242,6 +4831,12 @@ func (o MetricIdentifierOutput) ToMetricIdentifierPtrOutputWithContext(ctx conte }).(MetricIdentifierPtrOutput) } +func (o MetricIdentifierOutput) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifier] { + return pulumix.Output[MetricIdentifier]{ + OutputState: o.OutputState, + } +} + // name is the name of the given metric func (o MetricIdentifierOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v MetricIdentifier) string { return v.Name }).(pulumi.StringOutput) @@ -4266,6 +4861,12 @@ func (o MetricIdentifierPtrOutput) ToMetricIdentifierPtrOutputWithContext(ctx co return o } +func (o MetricIdentifierPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifier] { + return pulumix.Output[*MetricIdentifier]{ + OutputState: o.OutputState, + } +} + func (o MetricIdentifierPtrOutput) Elem() MetricIdentifierOutput { return o.ApplyT(func(v *MetricIdentifier) MetricIdentifier { if v != nil { @@ -4335,6 +4936,12 @@ func (i MetricIdentifierPatchArgs) ToMetricIdentifierPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierPatchOutput) } +func (i MetricIdentifierPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifierPatch] { + return pulumix.Output[MetricIdentifierPatch]{ + OutputState: i.ToMetricIdentifierPatchOutputWithContext(ctx).OutputState, + } +} + func (i MetricIdentifierPatchArgs) ToMetricIdentifierPatchPtrOutput() MetricIdentifierPatchPtrOutput { return i.ToMetricIdentifierPatchPtrOutputWithContext(context.Background()) } @@ -4376,6 +4983,12 @@ func (i *metricIdentifierPatchPtrType) ToMetricIdentifierPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(MetricIdentifierPatchPtrOutput) } +func (i *metricIdentifierPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifierPatch] { + return pulumix.Output[*MetricIdentifierPatch]{ + OutputState: i.ToMetricIdentifierPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MetricIdentifier defines the name and optionally selector for a metric type MetricIdentifierPatchOutput struct{ *pulumi.OutputState } @@ -4401,6 +5014,12 @@ func (o MetricIdentifierPatchOutput) ToMetricIdentifierPatchPtrOutputWithContext }).(MetricIdentifierPatchPtrOutput) } +func (o MetricIdentifierPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricIdentifierPatch] { + return pulumix.Output[MetricIdentifierPatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the given metric func (o MetricIdentifierPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v MetricIdentifierPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -4425,6 +5044,12 @@ func (o MetricIdentifierPatchPtrOutput) ToMetricIdentifierPatchPtrOutputWithCont return o } +func (o MetricIdentifierPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricIdentifierPatch] { + return pulumix.Output[*MetricIdentifierPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricIdentifierPatchPtrOutput) Elem() MetricIdentifierPatchOutput { return o.ApplyT(func(v *MetricIdentifierPatch) MetricIdentifierPatch { if v != nil { @@ -4510,6 +5135,12 @@ func (i MetricSpecArgs) ToMetricSpecOutputWithContext(ctx context.Context) Metri return pulumi.ToOutputWithContext(ctx, i).(MetricSpecOutput) } +func (i MetricSpecArgs) ToOutput(ctx context.Context) pulumix.Output[MetricSpec] { + return pulumix.Output[MetricSpec]{ + OutputState: i.ToMetricSpecOutputWithContext(ctx).OutputState, + } +} + // MetricSpecArrayInput is an input type that accepts MetricSpecArray and MetricSpecArrayOutput values. // You can construct a concrete instance of `MetricSpecArrayInput` via: // @@ -4535,6 +5166,12 @@ func (i MetricSpecArray) ToMetricSpecArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(MetricSpecArrayOutput) } +func (i MetricSpecArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpec] { + return pulumix.Output[[]MetricSpec]{ + OutputState: i.ToMetricSpecArrayOutputWithContext(ctx).OutputState, + } +} + // MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). type MetricSpecOutput struct{ *pulumi.OutputState } @@ -4550,6 +5187,12 @@ func (o MetricSpecOutput) ToMetricSpecOutputWithContext(ctx context.Context) Met return o } +func (o MetricSpecOutput) ToOutput(ctx context.Context) pulumix.Output[MetricSpec] { + return pulumix.Output[MetricSpec]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. func (o MetricSpecOutput) ContainerResource() ContainerResourceMetricSourcePtrOutput { return o.ApplyT(func(v MetricSpec) *ContainerResourceMetricSource { return v.ContainerResource }).(ContainerResourceMetricSourcePtrOutput) @@ -4594,6 +5237,12 @@ func (o MetricSpecArrayOutput) ToMetricSpecArrayOutputWithContext(ctx context.Co return o } +func (o MetricSpecArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpec] { + return pulumix.Output[[]MetricSpec]{ + OutputState: o.OutputState, + } +} + func (o MetricSpecArrayOutput) Index(i pulumi.IntInput) MetricSpecOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricSpec { return vs[0].([]MetricSpec)[vs[1].(int)] @@ -4655,6 +5304,12 @@ func (i MetricSpecPatchArgs) ToMetricSpecPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MetricSpecPatchOutput) } +func (i MetricSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricSpecPatch] { + return pulumix.Output[MetricSpecPatch]{ + OutputState: i.ToMetricSpecPatchOutputWithContext(ctx).OutputState, + } +} + // MetricSpecPatchArrayInput is an input type that accepts MetricSpecPatchArray and MetricSpecPatchArrayOutput values. // You can construct a concrete instance of `MetricSpecPatchArrayInput` via: // @@ -4680,6 +5335,12 @@ func (i MetricSpecPatchArray) ToMetricSpecPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(MetricSpecPatchArrayOutput) } +func (i MetricSpecPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpecPatch] { + return pulumix.Output[[]MetricSpecPatch]{ + OutputState: i.ToMetricSpecPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). type MetricSpecPatchOutput struct{ *pulumi.OutputState } @@ -4695,6 +5356,12 @@ func (o MetricSpecPatchOutput) ToMetricSpecPatchOutputWithContext(ctx context.Co return o } +func (o MetricSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricSpecPatch] { + return pulumix.Output[MetricSpecPatch]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. func (o MetricSpecPatchOutput) ContainerResource() ContainerResourceMetricSourcePatchPtrOutput { return o.ApplyT(func(v MetricSpecPatch) *ContainerResourceMetricSourcePatch { return v.ContainerResource }).(ContainerResourceMetricSourcePatchPtrOutput) @@ -4739,6 +5406,12 @@ func (o MetricSpecPatchArrayOutput) ToMetricSpecPatchArrayOutputWithContext(ctx return o } +func (o MetricSpecPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricSpecPatch] { + return pulumix.Output[[]MetricSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricSpecPatchArrayOutput) Index(i pulumi.IntInput) MetricSpecPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricSpecPatch { return vs[0].([]MetricSpecPatch)[vs[1].(int)] @@ -4800,6 +5473,12 @@ func (i MetricStatusArgs) ToMetricStatusOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(MetricStatusOutput) } +func (i MetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[MetricStatus] { + return pulumix.Output[MetricStatus]{ + OutputState: i.ToMetricStatusOutputWithContext(ctx).OutputState, + } +} + // MetricStatusArrayInput is an input type that accepts MetricStatusArray and MetricStatusArrayOutput values. // You can construct a concrete instance of `MetricStatusArrayInput` via: // @@ -4825,6 +5504,12 @@ func (i MetricStatusArray) ToMetricStatusArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(MetricStatusArrayOutput) } +func (i MetricStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatus] { + return pulumix.Output[[]MetricStatus]{ + OutputState: i.ToMetricStatusArrayOutputWithContext(ctx).OutputState, + } +} + // MetricStatus describes the last-read state of a single metric. type MetricStatusOutput struct{ *pulumi.OutputState } @@ -4840,6 +5525,12 @@ func (o MetricStatusOutput) ToMetricStatusOutputWithContext(ctx context.Context) return o } +func (o MetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[MetricStatus] { + return pulumix.Output[MetricStatus]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. func (o MetricStatusOutput) ContainerResource() ContainerResourceMetricStatusPtrOutput { return o.ApplyT(func(v MetricStatus) *ContainerResourceMetricStatus { return v.ContainerResource }).(ContainerResourceMetricStatusPtrOutput) @@ -4884,6 +5575,12 @@ func (o MetricStatusArrayOutput) ToMetricStatusArrayOutputWithContext(ctx contex return o } +func (o MetricStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatus] { + return pulumix.Output[[]MetricStatus]{ + OutputState: o.OutputState, + } +} + func (o MetricStatusArrayOutput) Index(i pulumi.IntInput) MetricStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricStatus { return vs[0].([]MetricStatus)[vs[1].(int)] @@ -4945,6 +5642,12 @@ func (i MetricStatusPatchArgs) ToMetricStatusPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricStatusPatchOutput) } +func (i MetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricStatusPatch] { + return pulumix.Output[MetricStatusPatch]{ + OutputState: i.ToMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + // MetricStatusPatchArrayInput is an input type that accepts MetricStatusPatchArray and MetricStatusPatchArrayOutput values. // You can construct a concrete instance of `MetricStatusPatchArrayInput` via: // @@ -4970,6 +5673,12 @@ func (i MetricStatusPatchArray) ToMetricStatusPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(MetricStatusPatchArrayOutput) } +func (i MetricStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatusPatch] { + return pulumix.Output[[]MetricStatusPatch]{ + OutputState: i.ToMetricStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // MetricStatus describes the last-read state of a single metric. type MetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -4985,6 +5694,12 @@ func (o MetricStatusPatchOutput) ToMetricStatusPatchOutputWithContext(ctx contex return o } +func (o MetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricStatusPatch] { + return pulumix.Output[MetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. func (o MetricStatusPatchOutput) ContainerResource() ContainerResourceMetricStatusPatchPtrOutput { return o.ApplyT(func(v MetricStatusPatch) *ContainerResourceMetricStatusPatch { return v.ContainerResource }).(ContainerResourceMetricStatusPatchPtrOutput) @@ -5029,6 +5744,12 @@ func (o MetricStatusPatchArrayOutput) ToMetricStatusPatchArrayOutputWithContext( return o } +func (o MetricStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]MetricStatusPatch] { + return pulumix.Output[[]MetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricStatusPatchArrayOutput) Index(i pulumi.IntInput) MetricStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) MetricStatusPatch { return vs[0].([]MetricStatusPatch)[vs[1].(int)] @@ -5082,6 +5803,12 @@ func (i MetricTargetArgs) ToMetricTargetOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(MetricTargetOutput) } +func (i MetricTargetArgs) ToOutput(ctx context.Context) pulumix.Output[MetricTarget] { + return pulumix.Output[MetricTarget]{ + OutputState: i.ToMetricTargetOutputWithContext(ctx).OutputState, + } +} + func (i MetricTargetArgs) ToMetricTargetPtrOutput() MetricTargetPtrOutput { return i.ToMetricTargetPtrOutputWithContext(context.Background()) } @@ -5123,6 +5850,12 @@ func (i *metricTargetPtrType) ToMetricTargetPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(MetricTargetPtrOutput) } +func (i *metricTargetPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricTarget] { + return pulumix.Output[*MetricTarget]{ + OutputState: i.ToMetricTargetPtrOutputWithContext(ctx).OutputState, + } +} + // MetricTarget defines the target value, average value, or average utilization of a specific metric type MetricTargetOutput struct{ *pulumi.OutputState } @@ -5148,6 +5881,12 @@ func (o MetricTargetOutput) ToMetricTargetPtrOutputWithContext(ctx context.Conte }).(MetricTargetPtrOutput) } +func (o MetricTargetOutput) ToOutput(ctx context.Context) pulumix.Output[MetricTarget] { + return pulumix.Output[MetricTarget]{ + OutputState: o.OutputState, + } +} + // averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type func (o MetricTargetOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricTarget) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5182,6 +5921,12 @@ func (o MetricTargetPtrOutput) ToMetricTargetPtrOutputWithContext(ctx context.Co return o } +func (o MetricTargetPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricTarget] { + return pulumix.Output[*MetricTarget]{ + OutputState: o.OutputState, + } +} + func (o MetricTargetPtrOutput) Elem() MetricTargetOutput { return o.ApplyT(func(v *MetricTarget) MetricTarget { if v != nil { @@ -5279,6 +6024,12 @@ func (i MetricTargetPatchArgs) ToMetricTargetPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricTargetPatchOutput) } +func (i MetricTargetPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricTargetPatch] { + return pulumix.Output[MetricTargetPatch]{ + OutputState: i.ToMetricTargetPatchOutputWithContext(ctx).OutputState, + } +} + func (i MetricTargetPatchArgs) ToMetricTargetPatchPtrOutput() MetricTargetPatchPtrOutput { return i.ToMetricTargetPatchPtrOutputWithContext(context.Background()) } @@ -5320,6 +6071,12 @@ func (i *metricTargetPatchPtrType) ToMetricTargetPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(MetricTargetPatchPtrOutput) } +func (i *metricTargetPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricTargetPatch] { + return pulumix.Output[*MetricTargetPatch]{ + OutputState: i.ToMetricTargetPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MetricTarget defines the target value, average value, or average utilization of a specific metric type MetricTargetPatchOutput struct{ *pulumi.OutputState } @@ -5345,6 +6102,12 @@ func (o MetricTargetPatchOutput) ToMetricTargetPatchPtrOutputWithContext(ctx con }).(MetricTargetPatchPtrOutput) } +func (o MetricTargetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricTargetPatch] { + return pulumix.Output[MetricTargetPatch]{ + OutputState: o.OutputState, + } +} + // averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type func (o MetricTargetPatchOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricTargetPatch) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5379,6 +6142,12 @@ func (o MetricTargetPatchPtrOutput) ToMetricTargetPatchPtrOutputWithContext(ctx return o } +func (o MetricTargetPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricTargetPatch] { + return pulumix.Output[*MetricTargetPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricTargetPatchPtrOutput) Elem() MetricTargetPatchOutput { return o.ApplyT(func(v *MetricTargetPatch) MetricTargetPatch { if v != nil { @@ -5472,6 +6241,12 @@ func (i MetricValueStatusArgs) ToMetricValueStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusOutput) } +func (i MetricValueStatusArgs) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatus] { + return pulumix.Output[MetricValueStatus]{ + OutputState: i.ToMetricValueStatusOutputWithContext(ctx).OutputState, + } +} + func (i MetricValueStatusArgs) ToMetricValueStatusPtrOutput() MetricValueStatusPtrOutput { return i.ToMetricValueStatusPtrOutputWithContext(context.Background()) } @@ -5513,6 +6288,12 @@ func (i *metricValueStatusPtrType) ToMetricValueStatusPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusPtrOutput) } +func (i *metricValueStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatus] { + return pulumix.Output[*MetricValueStatus]{ + OutputState: i.ToMetricValueStatusPtrOutputWithContext(ctx).OutputState, + } +} + // MetricValueStatus holds the current value for a metric type MetricValueStatusOutput struct{ *pulumi.OutputState } @@ -5538,6 +6319,12 @@ func (o MetricValueStatusOutput) ToMetricValueStatusPtrOutputWithContext(ctx con }).(MetricValueStatusPtrOutput) } +func (o MetricValueStatusOutput) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatus] { + return pulumix.Output[MetricValueStatus]{ + OutputState: o.OutputState, + } +} + // currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. func (o MetricValueStatusOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricValueStatus) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5567,6 +6354,12 @@ func (o MetricValueStatusPtrOutput) ToMetricValueStatusPtrOutputWithContext(ctx return o } +func (o MetricValueStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatus] { + return pulumix.Output[*MetricValueStatus]{ + OutputState: o.OutputState, + } +} + func (o MetricValueStatusPtrOutput) Elem() MetricValueStatusOutput { return o.ApplyT(func(v *MetricValueStatus) MetricValueStatus { if v != nil { @@ -5650,6 +6443,12 @@ func (i MetricValueStatusPatchArgs) ToMetricValueStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusPatchOutput) } +func (i MetricValueStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatusPatch] { + return pulumix.Output[MetricValueStatusPatch]{ + OutputState: i.ToMetricValueStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i MetricValueStatusPatchArgs) ToMetricValueStatusPatchPtrOutput() MetricValueStatusPatchPtrOutput { return i.ToMetricValueStatusPatchPtrOutputWithContext(context.Background()) } @@ -5691,6 +6490,12 @@ func (i *metricValueStatusPatchPtrType) ToMetricValueStatusPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(MetricValueStatusPatchPtrOutput) } +func (i *metricValueStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatusPatch] { + return pulumix.Output[*MetricValueStatusPatch]{ + OutputState: i.ToMetricValueStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // MetricValueStatus holds the current value for a metric type MetricValueStatusPatchOutput struct{ *pulumi.OutputState } @@ -5716,6 +6521,12 @@ func (o MetricValueStatusPatchOutput) ToMetricValueStatusPatchPtrOutputWithConte }).(MetricValueStatusPatchPtrOutput) } +func (o MetricValueStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[MetricValueStatusPatch] { + return pulumix.Output[MetricValueStatusPatch]{ + OutputState: o.OutputState, + } +} + // currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. func (o MetricValueStatusPatchOutput) AverageUtilization() pulumi.IntPtrOutput { return o.ApplyT(func(v MetricValueStatusPatch) *int { return v.AverageUtilization }).(pulumi.IntPtrOutput) @@ -5745,6 +6556,12 @@ func (o MetricValueStatusPatchPtrOutput) ToMetricValueStatusPatchPtrOutputWithCo return o } +func (o MetricValueStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*MetricValueStatusPatch] { + return pulumix.Output[*MetricValueStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o MetricValueStatusPatchPtrOutput) Elem() MetricValueStatusPatchOutput { return o.ApplyT(func(v *MetricValueStatusPatch) MetricValueStatusPatch { if v != nil { @@ -5826,6 +6643,12 @@ func (i ObjectMetricSourceArgs) ToObjectMetricSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourceOutput) } +func (i ObjectMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSource] { + return pulumix.Output[ObjectMetricSource]{ + OutputState: i.ToObjectMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricSourceArgs) ToObjectMetricSourcePtrOutput() ObjectMetricSourcePtrOutput { return i.ToObjectMetricSourcePtrOutputWithContext(context.Background()) } @@ -5867,6 +6690,12 @@ func (i *objectMetricSourcePtrType) ToObjectMetricSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePtrOutput) } +func (i *objectMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSource] { + return pulumix.Output[*ObjectMetricSource]{ + OutputState: i.ToObjectMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricSourceOutput struct{ *pulumi.OutputState } @@ -5892,6 +6721,12 @@ func (o ObjectMetricSourceOutput) ToObjectMetricSourcePtrOutputWithContext(ctx c }).(ObjectMetricSourcePtrOutput) } +func (o ObjectMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSource] { + return pulumix.Output[ObjectMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourceOutput) DescribedObject() CrossVersionObjectReferenceOutput { return o.ApplyT(func(v ObjectMetricSource) CrossVersionObjectReference { return v.DescribedObject }).(CrossVersionObjectReferenceOutput) } @@ -5920,6 +6755,12 @@ func (o ObjectMetricSourcePtrOutput) ToObjectMetricSourcePtrOutputWithContext(ct return o } +func (o ObjectMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSource] { + return pulumix.Output[*ObjectMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePtrOutput) Elem() ObjectMetricSourceOutput { return o.ApplyT(func(v *ObjectMetricSource) ObjectMetricSource { if v != nil { @@ -6000,6 +6841,12 @@ func (i ObjectMetricSourcePatchArgs) ToObjectMetricSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePatchOutput) } +func (i ObjectMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSourcePatch] { + return pulumix.Output[ObjectMetricSourcePatch]{ + OutputState: i.ToObjectMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricSourcePatchArgs) ToObjectMetricSourcePatchPtrOutput() ObjectMetricSourcePatchPtrOutput { return i.ToObjectMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -6041,6 +6888,12 @@ func (i *objectMetricSourcePatchPtrType) ToObjectMetricSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricSourcePatchPtrOutput) } +func (i *objectMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSourcePatch] { + return pulumix.Output[*ObjectMetricSourcePatch]{ + OutputState: i.ToObjectMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -6066,6 +6919,12 @@ func (o ObjectMetricSourcePatchOutput) ToObjectMetricSourcePatchPtrOutputWithCon }).(ObjectMetricSourcePatchPtrOutput) } +func (o ObjectMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricSourcePatch] { + return pulumix.Output[ObjectMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePatchOutput) DescribedObject() CrossVersionObjectReferencePatchPtrOutput { return o.ApplyT(func(v ObjectMetricSourcePatch) *CrossVersionObjectReferencePatch { return v.DescribedObject }).(CrossVersionObjectReferencePatchPtrOutput) } @@ -6094,6 +6953,12 @@ func (o ObjectMetricSourcePatchPtrOutput) ToObjectMetricSourcePatchPtrOutputWith return o } +func (o ObjectMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricSourcePatch] { + return pulumix.Output[*ObjectMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricSourcePatchPtrOutput) Elem() ObjectMetricSourcePatchOutput { return o.ApplyT(func(v *ObjectMetricSourcePatch) ObjectMetricSourcePatch { if v != nil { @@ -6174,6 +7039,12 @@ func (i ObjectMetricStatusArgs) ToObjectMetricStatusOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusOutput) } +func (i ObjectMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatus] { + return pulumix.Output[ObjectMetricStatus]{ + OutputState: i.ToObjectMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricStatusArgs) ToObjectMetricStatusPtrOutput() ObjectMetricStatusPtrOutput { return i.ToObjectMetricStatusPtrOutputWithContext(context.Background()) } @@ -6215,6 +7086,12 @@ func (i *objectMetricStatusPtrType) ToObjectMetricStatusPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPtrOutput) } +func (i *objectMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatus] { + return pulumix.Output[*ObjectMetricStatus]{ + OutputState: i.ToObjectMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricStatusOutput struct{ *pulumi.OutputState } @@ -6240,6 +7117,12 @@ func (o ObjectMetricStatusOutput) ToObjectMetricStatusPtrOutputWithContext(ctx c }).(ObjectMetricStatusPtrOutput) } +func (o ObjectMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatus] { + return pulumix.Output[ObjectMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ObjectMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v ObjectMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -6268,6 +7151,12 @@ func (o ObjectMetricStatusPtrOutput) ToObjectMetricStatusPtrOutputWithContext(ct return o } +func (o ObjectMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatus] { + return pulumix.Output[*ObjectMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricStatusPtrOutput) Elem() ObjectMetricStatusOutput { return o.ApplyT(func(v *ObjectMetricStatus) ObjectMetricStatus { if v != nil { @@ -6348,6 +7237,12 @@ func (i ObjectMetricStatusPatchArgs) ToObjectMetricStatusPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPatchOutput) } +func (i ObjectMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatusPatch] { + return pulumix.Output[ObjectMetricStatusPatch]{ + OutputState: i.ToObjectMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetricStatusPatchArgs) ToObjectMetricStatusPatchPtrOutput() ObjectMetricStatusPatchPtrOutput { return i.ToObjectMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -6389,6 +7284,12 @@ func (i *objectMetricStatusPatchPtrType) ToObjectMetricStatusPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ObjectMetricStatusPatchPtrOutput) } +func (i *objectMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatusPatch] { + return pulumix.Output[*ObjectMetricStatusPatch]{ + OutputState: i.ToObjectMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). type ObjectMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -6414,6 +7315,12 @@ func (o ObjectMetricStatusPatchOutput) ToObjectMetricStatusPatchPtrOutputWithCon }).(ObjectMetricStatusPatchPtrOutput) } +func (o ObjectMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetricStatusPatch] { + return pulumix.Output[ObjectMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ObjectMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v ObjectMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -6442,6 +7349,12 @@ func (o ObjectMetricStatusPatchPtrOutput) ToObjectMetricStatusPatchPtrOutputWith return o } +func (o ObjectMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetricStatusPatch] { + return pulumix.Output[*ObjectMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetricStatusPatchPtrOutput) Elem() ObjectMetricStatusPatchOutput { return o.ApplyT(func(v *ObjectMetricStatusPatch) ObjectMetricStatusPatch { if v != nil { @@ -6520,6 +7433,12 @@ func (i PodsMetricSourceArgs) ToPodsMetricSourceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourceOutput) } +func (i PodsMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSource] { + return pulumix.Output[PodsMetricSource]{ + OutputState: i.ToPodsMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricSourceArgs) ToPodsMetricSourcePtrOutput() PodsMetricSourcePtrOutput { return i.ToPodsMetricSourcePtrOutputWithContext(context.Background()) } @@ -6561,6 +7480,12 @@ func (i *podsMetricSourcePtrType) ToPodsMetricSourcePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePtrOutput) } +func (i *podsMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSource] { + return pulumix.Output[*PodsMetricSource]{ + OutputState: i.ToPodsMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. type PodsMetricSourceOutput struct{ *pulumi.OutputState } @@ -6586,6 +7511,12 @@ func (o PodsMetricSourceOutput) ToPodsMetricSourcePtrOutputWithContext(ctx conte }).(PodsMetricSourcePtrOutput) } +func (o PodsMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSource] { + return pulumix.Output[PodsMetricSource]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o PodsMetricSourceOutput) Metric() MetricIdentifierOutput { return o.ApplyT(func(v PodsMetricSource) MetricIdentifier { return v.Metric }).(MetricIdentifierOutput) @@ -6610,6 +7541,12 @@ func (o PodsMetricSourcePtrOutput) ToPodsMetricSourcePtrOutputWithContext(ctx co return o } +func (o PodsMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSource] { + return pulumix.Output[*PodsMetricSource]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricSourcePtrOutput) Elem() PodsMetricSourceOutput { return o.ApplyT(func(v *PodsMetricSource) PodsMetricSource { if v != nil { @@ -6679,6 +7616,12 @@ func (i PodsMetricSourcePatchArgs) ToPodsMetricSourcePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePatchOutput) } +func (i PodsMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSourcePatch] { + return pulumix.Output[PodsMetricSourcePatch]{ + OutputState: i.ToPodsMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricSourcePatchArgs) ToPodsMetricSourcePatchPtrOutput() PodsMetricSourcePatchPtrOutput { return i.ToPodsMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -6720,6 +7663,12 @@ func (i *podsMetricSourcePatchPtrType) ToPodsMetricSourcePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodsMetricSourcePatchPtrOutput) } +func (i *podsMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSourcePatch] { + return pulumix.Output[*PodsMetricSourcePatch]{ + OutputState: i.ToPodsMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. type PodsMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -6745,6 +7694,12 @@ func (o PodsMetricSourcePatchOutput) ToPodsMetricSourcePatchPtrOutputWithContext }).(PodsMetricSourcePatchPtrOutput) } +func (o PodsMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricSourcePatch] { + return pulumix.Output[PodsMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // metric identifies the target metric by name and selector func (o PodsMetricSourcePatchOutput) Metric() MetricIdentifierPatchPtrOutput { return o.ApplyT(func(v PodsMetricSourcePatch) *MetricIdentifierPatch { return v.Metric }).(MetricIdentifierPatchPtrOutput) @@ -6769,6 +7724,12 @@ func (o PodsMetricSourcePatchPtrOutput) ToPodsMetricSourcePatchPtrOutputWithCont return o } +func (o PodsMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricSourcePatch] { + return pulumix.Output[*PodsMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricSourcePatchPtrOutput) Elem() PodsMetricSourcePatchOutput { return o.ApplyT(func(v *PodsMetricSourcePatch) PodsMetricSourcePatch { if v != nil { @@ -6838,6 +7799,12 @@ func (i PodsMetricStatusArgs) ToPodsMetricStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusOutput) } +func (i PodsMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatus] { + return pulumix.Output[PodsMetricStatus]{ + OutputState: i.ToPodsMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricStatusArgs) ToPodsMetricStatusPtrOutput() PodsMetricStatusPtrOutput { return i.ToPodsMetricStatusPtrOutputWithContext(context.Background()) } @@ -6879,6 +7846,12 @@ func (i *podsMetricStatusPtrType) ToPodsMetricStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPtrOutput) } +func (i *podsMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatus] { + return pulumix.Output[*PodsMetricStatus]{ + OutputState: i.ToPodsMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). type PodsMetricStatusOutput struct{ *pulumi.OutputState } @@ -6904,6 +7877,12 @@ func (o PodsMetricStatusOutput) ToPodsMetricStatusPtrOutputWithContext(ctx conte }).(PodsMetricStatusPtrOutput) } +func (o PodsMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatus] { + return pulumix.Output[PodsMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o PodsMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v PodsMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -6928,6 +7907,12 @@ func (o PodsMetricStatusPtrOutput) ToPodsMetricStatusPtrOutputWithContext(ctx co return o } +func (o PodsMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatus] { + return pulumix.Output[*PodsMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricStatusPtrOutput) Elem() PodsMetricStatusOutput { return o.ApplyT(func(v *PodsMetricStatus) PodsMetricStatus { if v != nil { @@ -6997,6 +7982,12 @@ func (i PodsMetricStatusPatchArgs) ToPodsMetricStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPatchOutput) } +func (i PodsMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatusPatch] { + return pulumix.Output[PodsMetricStatusPatch]{ + OutputState: i.ToPodsMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodsMetricStatusPatchArgs) ToPodsMetricStatusPatchPtrOutput() PodsMetricStatusPatchPtrOutput { return i.ToPodsMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -7038,6 +8029,12 @@ func (i *podsMetricStatusPatchPtrType) ToPodsMetricStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodsMetricStatusPatchPtrOutput) } +func (i *podsMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatusPatch] { + return pulumix.Output[*PodsMetricStatusPatch]{ + OutputState: i.ToPodsMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). type PodsMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -7063,6 +8060,12 @@ func (o PodsMetricStatusPatchOutput) ToPodsMetricStatusPatchPtrOutputWithContext }).(PodsMetricStatusPatchPtrOutput) } +func (o PodsMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodsMetricStatusPatch] { + return pulumix.Output[PodsMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o PodsMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v PodsMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -7087,6 +8090,12 @@ func (o PodsMetricStatusPatchPtrOutput) ToPodsMetricStatusPatchPtrOutputWithCont return o } +func (o PodsMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodsMetricStatusPatch] { + return pulumix.Output[*PodsMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodsMetricStatusPatchPtrOutput) Elem() PodsMetricStatusPatchOutput { return o.ApplyT(func(v *PodsMetricStatusPatch) PodsMetricStatusPatch { if v != nil { @@ -7156,6 +8165,12 @@ func (i ResourceMetricSourceArgs) ToResourceMetricSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourceOutput) } +func (i ResourceMetricSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSource] { + return pulumix.Output[ResourceMetricSource]{ + OutputState: i.ToResourceMetricSourceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricSourceArgs) ToResourceMetricSourcePtrOutput() ResourceMetricSourcePtrOutput { return i.ToResourceMetricSourcePtrOutputWithContext(context.Background()) } @@ -7197,6 +8212,12 @@ func (i *resourceMetricSourcePtrType) ToResourceMetricSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePtrOutput) } +func (i *resourceMetricSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSource] { + return pulumix.Output[*ResourceMetricSource]{ + OutputState: i.ToResourceMetricSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ResourceMetricSourceOutput struct{ *pulumi.OutputState } @@ -7222,6 +8243,12 @@ func (o ResourceMetricSourceOutput) ToResourceMetricSourcePtrOutputWithContext(c }).(ResourceMetricSourcePtrOutput) } +func (o ResourceMetricSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSource] { + return pulumix.Output[ResourceMetricSource]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource in question. func (o ResourceMetricSourceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ResourceMetricSource) string { return v.Name }).(pulumi.StringOutput) @@ -7246,6 +8273,12 @@ func (o ResourceMetricSourcePtrOutput) ToResourceMetricSourcePtrOutputWithContex return o } +func (o ResourceMetricSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSource] { + return pulumix.Output[*ResourceMetricSource]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricSourcePtrOutput) Elem() ResourceMetricSourceOutput { return o.ApplyT(func(v *ResourceMetricSource) ResourceMetricSource { if v != nil { @@ -7315,6 +8348,12 @@ func (i ResourceMetricSourcePatchArgs) ToResourceMetricSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePatchOutput) } +func (i ResourceMetricSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSourcePatch] { + return pulumix.Output[ResourceMetricSourcePatch]{ + OutputState: i.ToResourceMetricSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricSourcePatchArgs) ToResourceMetricSourcePatchPtrOutput() ResourceMetricSourcePatchPtrOutput { return i.ToResourceMetricSourcePatchPtrOutputWithContext(context.Background()) } @@ -7356,6 +8395,12 @@ func (i *resourceMetricSourcePatchPtrType) ToResourceMetricSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricSourcePatchPtrOutput) } +func (i *resourceMetricSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSourcePatch] { + return pulumix.Output[*ResourceMetricSourcePatch]{ + OutputState: i.ToResourceMetricSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set. type ResourceMetricSourcePatchOutput struct{ *pulumi.OutputState } @@ -7381,6 +8426,12 @@ func (o ResourceMetricSourcePatchOutput) ToResourceMetricSourcePatchPtrOutputWit }).(ResourceMetricSourcePatchPtrOutput) } +func (o ResourceMetricSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricSourcePatch] { + return pulumix.Output[ResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the resource in question. func (o ResourceMetricSourcePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceMetricSourcePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -7405,6 +8456,12 @@ func (o ResourceMetricSourcePatchPtrOutput) ToResourceMetricSourcePatchPtrOutput return o } +func (o ResourceMetricSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricSourcePatch] { + return pulumix.Output[*ResourceMetricSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricSourcePatchPtrOutput) Elem() ResourceMetricSourcePatchOutput { return o.ApplyT(func(v *ResourceMetricSourcePatch) ResourceMetricSourcePatch { if v != nil { @@ -7474,6 +8531,12 @@ func (i ResourceMetricStatusArgs) ToResourceMetricStatusOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusOutput) } +func (i ResourceMetricStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatus] { + return pulumix.Output[ResourceMetricStatus]{ + OutputState: i.ToResourceMetricStatusOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricStatusArgs) ToResourceMetricStatusPtrOutput() ResourceMetricStatusPtrOutput { return i.ToResourceMetricStatusPtrOutputWithContext(context.Background()) } @@ -7515,6 +8578,12 @@ func (i *resourceMetricStatusPtrType) ToResourceMetricStatusPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPtrOutput) } +func (i *resourceMetricStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatus] { + return pulumix.Output[*ResourceMetricStatus]{ + OutputState: i.ToResourceMetricStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ResourceMetricStatusOutput struct{ *pulumi.OutputState } @@ -7540,6 +8609,12 @@ func (o ResourceMetricStatusOutput) ToResourceMetricStatusPtrOutputWithContext(c }).(ResourceMetricStatusPtrOutput) } +func (o ResourceMetricStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatus] { + return pulumix.Output[ResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ResourceMetricStatusOutput) Current() MetricValueStatusOutput { return o.ApplyT(func(v ResourceMetricStatus) MetricValueStatus { return v.Current }).(MetricValueStatusOutput) @@ -7564,6 +8639,12 @@ func (o ResourceMetricStatusPtrOutput) ToResourceMetricStatusPtrOutputWithContex return o } +func (o ResourceMetricStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatus] { + return pulumix.Output[*ResourceMetricStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricStatusPtrOutput) Elem() ResourceMetricStatusOutput { return o.ApplyT(func(v *ResourceMetricStatus) ResourceMetricStatus { if v != nil { @@ -7633,6 +8714,12 @@ func (i ResourceMetricStatusPatchArgs) ToResourceMetricStatusPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPatchOutput) } +func (i ResourceMetricStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatusPatch] { + return pulumix.Output[ResourceMetricStatusPatch]{ + OutputState: i.ToResourceMetricStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceMetricStatusPatchArgs) ToResourceMetricStatusPatchPtrOutput() ResourceMetricStatusPatchPtrOutput { return i.ToResourceMetricStatusPatchPtrOutputWithContext(context.Background()) } @@ -7674,6 +8761,12 @@ func (i *resourceMetricStatusPatchPtrType) ToResourceMetricStatusPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceMetricStatusPatchPtrOutput) } +func (i *resourceMetricStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatusPatch] { + return pulumix.Output[*ResourceMetricStatusPatch]{ + OutputState: i.ToResourceMetricStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. type ResourceMetricStatusPatchOutput struct{ *pulumi.OutputState } @@ -7699,6 +8792,12 @@ func (o ResourceMetricStatusPatchOutput) ToResourceMetricStatusPatchPtrOutputWit }).(ResourceMetricStatusPatchPtrOutput) } +func (o ResourceMetricStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceMetricStatusPatch] { + return pulumix.Output[ResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + // current contains the current value for the given metric func (o ResourceMetricStatusPatchOutput) Current() MetricValueStatusPatchPtrOutput { return o.ApplyT(func(v ResourceMetricStatusPatch) *MetricValueStatusPatch { return v.Current }).(MetricValueStatusPatchPtrOutput) @@ -7723,6 +8822,12 @@ func (o ResourceMetricStatusPatchPtrOutput) ToResourceMetricStatusPatchPtrOutput return o } +func (o ResourceMetricStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceMetricStatusPatch] { + return pulumix.Output[*ResourceMetricStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceMetricStatusPatchPtrOutput) Elem() ResourceMetricStatusPatchOutput { return o.ApplyT(func(v *ResourceMetricStatusPatch) ResourceMetricStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/batch/v1/cronJob.go b/sdk/go/kubernetes/batch/v1/cronJob.go index 88e1619210..a00074b1bd 100644 --- a/sdk/go/kubernetes/batch/v1/cronJob.go +++ b/sdk/go/kubernetes/batch/v1/cronJob.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CronJob represents the configuration of a single cron job. @@ -124,6 +125,12 @@ func (i *CronJob) ToCronJobOutputWithContext(ctx context.Context) CronJobOutput return pulumi.ToOutputWithContext(ctx, i).(CronJobOutput) } +func (i *CronJob) ToOutput(ctx context.Context) pulumix.Output[*CronJob] { + return pulumix.Output[*CronJob]{ + OutputState: i.ToCronJobOutputWithContext(ctx).OutputState, + } +} + // CronJobArrayInput is an input type that accepts CronJobArray and CronJobArrayOutput values. // You can construct a concrete instance of `CronJobArrayInput` via: // @@ -149,6 +156,12 @@ func (i CronJobArray) ToCronJobArrayOutputWithContext(ctx context.Context) CronJ return pulumi.ToOutputWithContext(ctx, i).(CronJobArrayOutput) } +func (i CronJobArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJob] { + return pulumix.Output[[]*CronJob]{ + OutputState: i.ToCronJobArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobMapInput is an input type that accepts CronJobMap and CronJobMapOutput values. // You can construct a concrete instance of `CronJobMapInput` via: // @@ -174,6 +187,12 @@ func (i CronJobMap) ToCronJobMapOutputWithContext(ctx context.Context) CronJobMa return pulumi.ToOutputWithContext(ctx, i).(CronJobMapOutput) } +func (i CronJobMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJob] { + return pulumix.Output[map[string]*CronJob]{ + OutputState: i.ToCronJobMapOutputWithContext(ctx).OutputState, + } +} + type CronJobOutput struct{ *pulumi.OutputState } func (CronJobOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o CronJobOutput) ToCronJobOutputWithContext(ctx context.Context) CronJobOu return o } +func (o CronJobOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJob] { + return pulumix.Output[*CronJob]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CronJob) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -227,6 +252,12 @@ func (o CronJobArrayOutput) ToCronJobArrayOutputWithContext(ctx context.Context) return o } +func (o CronJobArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJob] { + return pulumix.Output[[]*CronJob]{ + OutputState: o.OutputState, + } +} + func (o CronJobArrayOutput) Index(i pulumi.IntInput) CronJobOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJob { return vs[0].([]*CronJob)[vs[1].(int)] @@ -247,6 +278,12 @@ func (o CronJobMapOutput) ToCronJobMapOutputWithContext(ctx context.Context) Cro return o } +func (o CronJobMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJob] { + return pulumix.Output[map[string]*CronJob]{ + OutputState: o.OutputState, + } +} + func (o CronJobMapOutput) MapIndex(k pulumi.StringInput) CronJobOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJob { return vs[0].(map[string]*CronJob)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1/cronJobList.go b/sdk/go/kubernetes/batch/v1/cronJobList.go index 3743d6b50d..652db88c3d 100644 --- a/sdk/go/kubernetes/batch/v1/cronJobList.go +++ b/sdk/go/kubernetes/batch/v1/cronJobList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CronJobList is a collection of cron jobs. @@ -117,6 +118,12 @@ func (i *CronJobList) ToCronJobListOutputWithContext(ctx context.Context) CronJo return pulumi.ToOutputWithContext(ctx, i).(CronJobListOutput) } +func (i *CronJobList) ToOutput(ctx context.Context) pulumix.Output[*CronJobList] { + return pulumix.Output[*CronJobList]{ + OutputState: i.ToCronJobListOutputWithContext(ctx).OutputState, + } +} + // CronJobListArrayInput is an input type that accepts CronJobListArray and CronJobListArrayOutput values. // You can construct a concrete instance of `CronJobListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CronJobListArray) ToCronJobListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CronJobListArrayOutput) } +func (i CronJobListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobList] { + return pulumix.Output[[]*CronJobList]{ + OutputState: i.ToCronJobListArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobListMapInput is an input type that accepts CronJobListMap and CronJobListMapOutput values. // You can construct a concrete instance of `CronJobListMapInput` via: // @@ -167,6 +180,12 @@ func (i CronJobListMap) ToCronJobListMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CronJobListMapOutput) } +func (i CronJobListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobList] { + return pulumix.Output[map[string]*CronJobList]{ + OutputState: i.ToCronJobListMapOutputWithContext(ctx).OutputState, + } +} + type CronJobListOutput struct{ *pulumi.OutputState } func (CronJobListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CronJobListOutput) ToCronJobListOutputWithContext(ctx context.Context) C return o } +func (o CronJobListOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobList] { + return pulumix.Output[*CronJobList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CronJobList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CronJobListArrayOutput) ToCronJobListArrayOutputWithContext(ctx context. return o } +func (o CronJobListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobList] { + return pulumix.Output[[]*CronJobList]{ + OutputState: o.OutputState, + } +} + func (o CronJobListArrayOutput) Index(i pulumi.IntInput) CronJobListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJobList { return vs[0].([]*CronJobList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CronJobListMapOutput) ToCronJobListMapOutputWithContext(ctx context.Cont return o } +func (o CronJobListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobList] { + return pulumix.Output[map[string]*CronJobList]{ + OutputState: o.OutputState, + } +} + func (o CronJobListMapOutput) MapIndex(k pulumi.StringInput) CronJobListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJobList { return vs[0].(map[string]*CronJobList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1/cronJobPatch.go b/sdk/go/kubernetes/batch/v1/cronJobPatch.go index f0e1e3f021..9e6dadbdc1 100644 --- a/sdk/go/kubernetes/batch/v1/cronJobPatch.go +++ b/sdk/go/kubernetes/batch/v1/cronJobPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *CronJobPatch) ToCronJobPatchOutputWithContext(ctx context.Context) Cron return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchOutput) } +func (i *CronJobPatch) ToOutput(ctx context.Context) pulumix.Output[*CronJobPatch] { + return pulumix.Output[*CronJobPatch]{ + OutputState: i.ToCronJobPatchOutputWithContext(ctx).OutputState, + } +} + // CronJobPatchArrayInput is an input type that accepts CronJobPatchArray and CronJobPatchArrayOutput values. // You can construct a concrete instance of `CronJobPatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i CronJobPatchArray) ToCronJobPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchArrayOutput) } +func (i CronJobPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobPatch] { + return pulumix.Output[[]*CronJobPatch]{ + OutputState: i.ToCronJobPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobPatchMapInput is an input type that accepts CronJobPatchMap and CronJobPatchMapOutput values. // You can construct a concrete instance of `CronJobPatchMapInput` via: // @@ -180,6 +193,12 @@ func (i CronJobPatchMap) ToCronJobPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchMapOutput) } +func (i CronJobPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobPatch] { + return pulumix.Output[map[string]*CronJobPatch]{ + OutputState: i.ToCronJobPatchMapOutputWithContext(ctx).OutputState, + } +} + type CronJobPatchOutput struct{ *pulumi.OutputState } func (CronJobPatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o CronJobPatchOutput) ToCronJobPatchOutputWithContext(ctx context.Context) return o } +func (o CronJobPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobPatch] { + return pulumix.Output[*CronJobPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CronJobPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -233,6 +258,12 @@ func (o CronJobPatchArrayOutput) ToCronJobPatchArrayOutputWithContext(ctx contex return o } +func (o CronJobPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobPatch] { + return pulumix.Output[[]*CronJobPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobPatchArrayOutput) Index(i pulumi.IntInput) CronJobPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJobPatch { return vs[0].([]*CronJobPatch)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o CronJobPatchMapOutput) ToCronJobPatchMapOutputWithContext(ctx context.Co return o } +func (o CronJobPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobPatch] { + return pulumix.Output[map[string]*CronJobPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobPatchMapOutput) MapIndex(k pulumi.StringInput) CronJobPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJobPatch { return vs[0].(map[string]*CronJobPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1/job.go b/sdk/go/kubernetes/batch/v1/job.go index 44fe3bc865..2b55f4e50c 100644 --- a/sdk/go/kubernetes/batch/v1/job.go +++ b/sdk/go/kubernetes/batch/v1/job.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Job represents the configuration of a single job. @@ -231,6 +232,12 @@ func (i *Job) ToJobOutputWithContext(ctx context.Context) JobOutput { return pulumi.ToOutputWithContext(ctx, i).(JobOutput) } +func (i *Job) ToOutput(ctx context.Context) pulumix.Output[*Job] { + return pulumix.Output[*Job]{ + OutputState: i.ToJobOutputWithContext(ctx).OutputState, + } +} + // JobArrayInput is an input type that accepts JobArray and JobArrayOutput values. // You can construct a concrete instance of `JobArrayInput` via: // @@ -256,6 +263,12 @@ func (i JobArray) ToJobArrayOutputWithContext(ctx context.Context) JobArrayOutpu return pulumi.ToOutputWithContext(ctx, i).(JobArrayOutput) } +func (i JobArray) ToOutput(ctx context.Context) pulumix.Output[[]*Job] { + return pulumix.Output[[]*Job]{ + OutputState: i.ToJobArrayOutputWithContext(ctx).OutputState, + } +} + // JobMapInput is an input type that accepts JobMap and JobMapOutput values. // You can construct a concrete instance of `JobMapInput` via: // @@ -281,6 +294,12 @@ func (i JobMap) ToJobMapOutputWithContext(ctx context.Context) JobMapOutput { return pulumi.ToOutputWithContext(ctx, i).(JobMapOutput) } +func (i JobMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Job] { + return pulumix.Output[map[string]*Job]{ + OutputState: i.ToJobMapOutputWithContext(ctx).OutputState, + } +} + type JobOutput struct{ *pulumi.OutputState } func (JobOutput) ElementType() reflect.Type { @@ -295,6 +314,12 @@ func (o JobOutput) ToJobOutputWithContext(ctx context.Context) JobOutput { return o } +func (o JobOutput) ToOutput(ctx context.Context) pulumix.Output[*Job] { + return pulumix.Output[*Job]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o JobOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Job) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -334,6 +359,12 @@ func (o JobArrayOutput) ToJobArrayOutputWithContext(ctx context.Context) JobArra return o } +func (o JobArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Job] { + return pulumix.Output[[]*Job]{ + OutputState: o.OutputState, + } +} + func (o JobArrayOutput) Index(i pulumi.IntInput) JobOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Job { return vs[0].([]*Job)[vs[1].(int)] @@ -354,6 +385,12 @@ func (o JobMapOutput) ToJobMapOutputWithContext(ctx context.Context) JobMapOutpu return o } +func (o JobMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Job] { + return pulumix.Output[map[string]*Job]{ + OutputState: o.OutputState, + } +} + func (o JobMapOutput) MapIndex(k pulumi.StringInput) JobOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Job { return vs[0].(map[string]*Job)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1/jobList.go b/sdk/go/kubernetes/batch/v1/jobList.go index 6cd3943337..7d205d0624 100644 --- a/sdk/go/kubernetes/batch/v1/jobList.go +++ b/sdk/go/kubernetes/batch/v1/jobList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // JobList is a collection of jobs. @@ -117,6 +118,12 @@ func (i *JobList) ToJobListOutputWithContext(ctx context.Context) JobListOutput return pulumi.ToOutputWithContext(ctx, i).(JobListOutput) } +func (i *JobList) ToOutput(ctx context.Context) pulumix.Output[*JobList] { + return pulumix.Output[*JobList]{ + OutputState: i.ToJobListOutputWithContext(ctx).OutputState, + } +} + // JobListArrayInput is an input type that accepts JobListArray and JobListArrayOutput values. // You can construct a concrete instance of `JobListArrayInput` via: // @@ -142,6 +149,12 @@ func (i JobListArray) ToJobListArrayOutputWithContext(ctx context.Context) JobLi return pulumi.ToOutputWithContext(ctx, i).(JobListArrayOutput) } +func (i JobListArray) ToOutput(ctx context.Context) pulumix.Output[[]*JobList] { + return pulumix.Output[[]*JobList]{ + OutputState: i.ToJobListArrayOutputWithContext(ctx).OutputState, + } +} + // JobListMapInput is an input type that accepts JobListMap and JobListMapOutput values. // You can construct a concrete instance of `JobListMapInput` via: // @@ -167,6 +180,12 @@ func (i JobListMap) ToJobListMapOutputWithContext(ctx context.Context) JobListMa return pulumi.ToOutputWithContext(ctx, i).(JobListMapOutput) } +func (i JobListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*JobList] { + return pulumix.Output[map[string]*JobList]{ + OutputState: i.ToJobListMapOutputWithContext(ctx).OutputState, + } +} + type JobListOutput struct{ *pulumi.OutputState } func (JobListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o JobListOutput) ToJobListOutputWithContext(ctx context.Context) JobListOu return o } +func (o JobListOutput) ToOutput(ctx context.Context) pulumix.Output[*JobList] { + return pulumix.Output[*JobList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o JobListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *JobList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o JobListArrayOutput) ToJobListArrayOutputWithContext(ctx context.Context) return o } +func (o JobListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*JobList] { + return pulumix.Output[[]*JobList]{ + OutputState: o.OutputState, + } +} + func (o JobListArrayOutput) Index(i pulumi.IntInput) JobListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *JobList { return vs[0].([]*JobList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o JobListMapOutput) ToJobListMapOutputWithContext(ctx context.Context) Job return o } +func (o JobListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*JobList] { + return pulumix.Output[map[string]*JobList]{ + OutputState: o.OutputState, + } +} + func (o JobListMapOutput) MapIndex(k pulumi.StringInput) JobListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *JobList { return vs[0].(map[string]*JobList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1/jobPatch.go b/sdk/go/kubernetes/batch/v1/jobPatch.go index 0a10ac92de..bff3e228f3 100644 --- a/sdk/go/kubernetes/batch/v1/jobPatch.go +++ b/sdk/go/kubernetes/batch/v1/jobPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -141,6 +142,12 @@ func (i *JobPatch) ToJobPatchOutputWithContext(ctx context.Context) JobPatchOutp return pulumi.ToOutputWithContext(ctx, i).(JobPatchOutput) } +func (i *JobPatch) ToOutput(ctx context.Context) pulumix.Output[*JobPatch] { + return pulumix.Output[*JobPatch]{ + OutputState: i.ToJobPatchOutputWithContext(ctx).OutputState, + } +} + // JobPatchArrayInput is an input type that accepts JobPatchArray and JobPatchArrayOutput values. // You can construct a concrete instance of `JobPatchArrayInput` via: // @@ -166,6 +173,12 @@ func (i JobPatchArray) ToJobPatchArrayOutputWithContext(ctx context.Context) Job return pulumi.ToOutputWithContext(ctx, i).(JobPatchArrayOutput) } +func (i JobPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*JobPatch] { + return pulumix.Output[[]*JobPatch]{ + OutputState: i.ToJobPatchArrayOutputWithContext(ctx).OutputState, + } +} + // JobPatchMapInput is an input type that accepts JobPatchMap and JobPatchMapOutput values. // You can construct a concrete instance of `JobPatchMapInput` via: // @@ -191,6 +204,12 @@ func (i JobPatchMap) ToJobPatchMapOutputWithContext(ctx context.Context) JobPatc return pulumi.ToOutputWithContext(ctx, i).(JobPatchMapOutput) } +func (i JobPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*JobPatch] { + return pulumix.Output[map[string]*JobPatch]{ + OutputState: i.ToJobPatchMapOutputWithContext(ctx).OutputState, + } +} + type JobPatchOutput struct{ *pulumi.OutputState } func (JobPatchOutput) ElementType() reflect.Type { @@ -205,6 +224,12 @@ func (o JobPatchOutput) ToJobPatchOutputWithContext(ctx context.Context) JobPatc return o } +func (o JobPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*JobPatch] { + return pulumix.Output[*JobPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o JobPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *JobPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -244,6 +269,12 @@ func (o JobPatchArrayOutput) ToJobPatchArrayOutputWithContext(ctx context.Contex return o } +func (o JobPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*JobPatch] { + return pulumix.Output[[]*JobPatch]{ + OutputState: o.OutputState, + } +} + func (o JobPatchArrayOutput) Index(i pulumi.IntInput) JobPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *JobPatch { return vs[0].([]*JobPatch)[vs[1].(int)] @@ -264,6 +295,12 @@ func (o JobPatchMapOutput) ToJobPatchMapOutputWithContext(ctx context.Context) J return o } +func (o JobPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*JobPatch] { + return pulumix.Output[map[string]*JobPatch]{ + OutputState: o.OutputState, + } +} + func (o JobPatchMapOutput) MapIndex(k pulumi.StringInput) JobPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *JobPatch { return vs[0].(map[string]*JobPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1/pulumiTypes.go b/sdk/go/kubernetes/batch/v1/pulumiTypes.go index 88015e1a5b..9323d089cc 100644 --- a/sdk/go/kubernetes/batch/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/batch/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -66,6 +67,12 @@ func (i CronJobTypeArgs) ToCronJobTypeOutputWithContext(ctx context.Context) Cro return pulumi.ToOutputWithContext(ctx, i).(CronJobTypeOutput) } +func (i CronJobTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobType] { + return pulumix.Output[CronJobType]{ + OutputState: i.ToCronJobTypeOutputWithContext(ctx).OutputState, + } +} + // CronJobTypeArrayInput is an input type that accepts CronJobTypeArray and CronJobTypeArrayOutput values. // You can construct a concrete instance of `CronJobTypeArrayInput` via: // @@ -91,6 +98,12 @@ func (i CronJobTypeArray) ToCronJobTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CronJobTypeArrayOutput) } +func (i CronJobTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CronJobType] { + return pulumix.Output[[]CronJobType]{ + OutputState: i.ToCronJobTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CronJob represents the configuration of a single cron job. type CronJobTypeOutput struct{ *pulumi.OutputState } @@ -106,6 +119,12 @@ func (o CronJobTypeOutput) ToCronJobTypeOutputWithContext(ctx context.Context) C return o } +func (o CronJobTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobType] { + return pulumix.Output[CronJobType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -145,6 +164,12 @@ func (o CronJobTypeArrayOutput) ToCronJobTypeArrayOutputWithContext(ctx context. return o } +func (o CronJobTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CronJobType] { + return pulumix.Output[[]CronJobType]{ + OutputState: o.OutputState, + } +} + func (o CronJobTypeArrayOutput) Index(i pulumi.IntInput) CronJobTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CronJobType { return vs[0].([]CronJobType)[vs[1].(int)] @@ -198,6 +223,12 @@ func (i CronJobListTypeArgs) ToCronJobListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CronJobListTypeOutput) } +func (i CronJobListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobListType] { + return pulumix.Output[CronJobListType]{ + OutputState: i.ToCronJobListTypeOutputWithContext(ctx).OutputState, + } +} + // CronJobList is a collection of cron jobs. type CronJobListTypeOutput struct{ *pulumi.OutputState } @@ -213,6 +244,12 @@ func (o CronJobListTypeOutput) ToCronJobListTypeOutputWithContext(ctx context.Co return o } +func (o CronJobListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobListType] { + return pulumix.Output[CronJobListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -284,6 +321,12 @@ func (i CronJobPatchTypeArgs) ToCronJobPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchTypeOutput) } +func (i CronJobPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobPatchType] { + return pulumix.Output[CronJobPatchType]{ + OutputState: i.ToCronJobPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CronJob represents the configuration of a single cron job. type CronJobPatchTypeOutput struct{ *pulumi.OutputState } @@ -299,6 +342,12 @@ func (o CronJobPatchTypeOutput) ToCronJobPatchTypeOutputWithContext(ctx context. return o } +func (o CronJobPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobPatchType] { + return pulumix.Output[CronJobPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -391,6 +440,12 @@ func (i CronJobSpecArgs) ToCronJobSpecOutputWithContext(ctx context.Context) Cro return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecOutput) } +func (i CronJobSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobSpec] { + return pulumix.Output[CronJobSpec]{ + OutputState: i.ToCronJobSpecOutputWithContext(ctx).OutputState, + } +} + func (i CronJobSpecArgs) ToCronJobSpecPtrOutput() CronJobSpecPtrOutput { return i.ToCronJobSpecPtrOutputWithContext(context.Background()) } @@ -432,6 +487,12 @@ func (i *cronJobSpecPtrType) ToCronJobSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPtrOutput) } +func (i *cronJobSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpec] { + return pulumix.Output[*CronJobSpec]{ + OutputState: i.ToCronJobSpecPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobSpec describes how the job execution will look like and when it will actually run. type CronJobSpecOutput struct{ *pulumi.OutputState } @@ -457,6 +518,12 @@ func (o CronJobSpecOutput) ToCronJobSpecPtrOutputWithContext(ctx context.Context }).(CronJobSpecPtrOutput) } +func (o CronJobSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobSpec] { + return pulumix.Output[CronJobSpec]{ + OutputState: o.OutputState, + } +} + // Specifies how to treat concurrent executions of a Job. Valid values are: // // - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one @@ -513,6 +580,12 @@ func (o CronJobSpecPtrOutput) ToCronJobSpecPtrOutputWithContext(ctx context.Cont return o } +func (o CronJobSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpec] { + return pulumix.Output[*CronJobSpec]{ + OutputState: o.OutputState, + } +} + func (o CronJobSpecPtrOutput) Elem() CronJobSpecOutput { return o.ApplyT(func(v *CronJobSpec) CronJobSpec { if v != nil { @@ -672,6 +745,12 @@ func (i CronJobSpecPatchArgs) ToCronJobSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPatchOutput) } +func (i CronJobSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobSpecPatch] { + return pulumix.Output[CronJobSpecPatch]{ + OutputState: i.ToCronJobSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CronJobSpecPatchArgs) ToCronJobSpecPatchPtrOutput() CronJobSpecPatchPtrOutput { return i.ToCronJobSpecPatchPtrOutputWithContext(context.Background()) } @@ -713,6 +792,12 @@ func (i *cronJobSpecPatchPtrType) ToCronJobSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPatchPtrOutput) } +func (i *cronJobSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpecPatch] { + return pulumix.Output[*CronJobSpecPatch]{ + OutputState: i.ToCronJobSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobSpec describes how the job execution will look like and when it will actually run. type CronJobSpecPatchOutput struct{ *pulumi.OutputState } @@ -738,6 +823,12 @@ func (o CronJobSpecPatchOutput) ToCronJobSpecPatchPtrOutputWithContext(ctx conte }).(CronJobSpecPatchPtrOutput) } +func (o CronJobSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobSpecPatch] { + return pulumix.Output[CronJobSpecPatch]{ + OutputState: o.OutputState, + } +} + // Specifies how to treat concurrent executions of a Job. Valid values are: // // - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one @@ -794,6 +885,12 @@ func (o CronJobSpecPatchPtrOutput) ToCronJobSpecPatchPtrOutputWithContext(ctx co return o } +func (o CronJobSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpecPatch] { + return pulumix.Output[*CronJobSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobSpecPatchPtrOutput) Elem() CronJobSpecPatchOutput { return o.ApplyT(func(v *CronJobSpecPatch) CronJobSpecPatch { if v != nil { @@ -929,6 +1026,12 @@ func (i CronJobStatusArgs) ToCronJobStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusOutput) } +func (i CronJobStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobStatus] { + return pulumix.Output[CronJobStatus]{ + OutputState: i.ToCronJobStatusOutputWithContext(ctx).OutputState, + } +} + func (i CronJobStatusArgs) ToCronJobStatusPtrOutput() CronJobStatusPtrOutput { return i.ToCronJobStatusPtrOutputWithContext(context.Background()) } @@ -970,6 +1073,12 @@ func (i *cronJobStatusPtrType) ToCronJobStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPtrOutput) } +func (i *cronJobStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatus] { + return pulumix.Output[*CronJobStatus]{ + OutputState: i.ToCronJobStatusPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobStatus represents the current state of a cron job. type CronJobStatusOutput struct{ *pulumi.OutputState } @@ -995,6 +1104,12 @@ func (o CronJobStatusOutput) ToCronJobStatusPtrOutputWithContext(ctx context.Con }).(CronJobStatusPtrOutput) } +func (o CronJobStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobStatus] { + return pulumix.Output[CronJobStatus]{ + OutputState: o.OutputState, + } +} + // A list of pointers to currently running jobs. func (o CronJobStatusOutput) Active() corev1.ObjectReferenceArrayOutput { return o.ApplyT(func(v CronJobStatus) []corev1.ObjectReference { return v.Active }).(corev1.ObjectReferenceArrayOutput) @@ -1024,6 +1139,12 @@ func (o CronJobStatusPtrOutput) ToCronJobStatusPtrOutputWithContext(ctx context. return o } +func (o CronJobStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatus] { + return pulumix.Output[*CronJobStatus]{ + OutputState: o.OutputState, + } +} + func (o CronJobStatusPtrOutput) Elem() CronJobStatusOutput { return o.ApplyT(func(v *CronJobStatus) CronJobStatus { if v != nil { @@ -1107,6 +1228,12 @@ func (i CronJobStatusPatchArgs) ToCronJobStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPatchOutput) } +func (i CronJobStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobStatusPatch] { + return pulumix.Output[CronJobStatusPatch]{ + OutputState: i.ToCronJobStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CronJobStatusPatchArgs) ToCronJobStatusPatchPtrOutput() CronJobStatusPatchPtrOutput { return i.ToCronJobStatusPatchPtrOutputWithContext(context.Background()) } @@ -1148,6 +1275,12 @@ func (i *cronJobStatusPatchPtrType) ToCronJobStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPatchPtrOutput) } +func (i *cronJobStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatusPatch] { + return pulumix.Output[*CronJobStatusPatch]{ + OutputState: i.ToCronJobStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobStatus represents the current state of a cron job. type CronJobStatusPatchOutput struct{ *pulumi.OutputState } @@ -1173,6 +1306,12 @@ func (o CronJobStatusPatchOutput) ToCronJobStatusPatchPtrOutputWithContext(ctx c }).(CronJobStatusPatchPtrOutput) } +func (o CronJobStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobStatusPatch] { + return pulumix.Output[CronJobStatusPatch]{ + OutputState: o.OutputState, + } +} + // A list of pointers to currently running jobs. func (o CronJobStatusPatchOutput) Active() corev1.ObjectReferencePatchArrayOutput { return o.ApplyT(func(v CronJobStatusPatch) []corev1.ObjectReferencePatch { return v.Active }).(corev1.ObjectReferencePatchArrayOutput) @@ -1202,6 +1341,12 @@ func (o CronJobStatusPatchPtrOutput) ToCronJobStatusPatchPtrOutputWithContext(ct return o } +func (o CronJobStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatusPatch] { + return pulumix.Output[*CronJobStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobStatusPatchPtrOutput) Elem() CronJobStatusPatchOutput { return o.ApplyT(func(v *CronJobStatusPatch) CronJobStatusPatch { if v != nil { @@ -1333,6 +1478,12 @@ func (i JobTypeArgs) ToJobTypeOutputWithContext(ctx context.Context) JobTypeOutp return pulumi.ToOutputWithContext(ctx, i).(JobTypeOutput) } +func (i JobTypeArgs) ToOutput(ctx context.Context) pulumix.Output[JobType] { + return pulumix.Output[JobType]{ + OutputState: i.ToJobTypeOutputWithContext(ctx).OutputState, + } +} + // JobTypeArrayInput is an input type that accepts JobTypeArray and JobTypeArrayOutput values. // You can construct a concrete instance of `JobTypeArrayInput` via: // @@ -1358,6 +1509,12 @@ func (i JobTypeArray) ToJobTypeArrayOutputWithContext(ctx context.Context) JobTy return pulumi.ToOutputWithContext(ctx, i).(JobTypeArrayOutput) } +func (i JobTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]JobType] { + return pulumix.Output[[]JobType]{ + OutputState: i.ToJobTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Job represents the configuration of a single job. // // This resource waits until its status is ready before registering success @@ -1393,6 +1550,12 @@ func (o JobTypeOutput) ToJobTypeOutputWithContext(ctx context.Context) JobTypeOu return o } +func (o JobTypeOutput) ToOutput(ctx context.Context) pulumix.Output[JobType] { + return pulumix.Output[JobType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o JobTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v JobType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1432,6 +1595,12 @@ func (o JobTypeArrayOutput) ToJobTypeArrayOutputWithContext(ctx context.Context) return o } +func (o JobTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JobType] { + return pulumix.Output[[]JobType]{ + OutputState: o.OutputState, + } +} + func (o JobTypeArrayOutput) Index(i pulumi.IntInput) JobTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JobType { return vs[0].([]JobType)[vs[1].(int)] @@ -1493,6 +1662,12 @@ func (i JobConditionArgs) ToJobConditionOutputWithContext(ctx context.Context) J return pulumi.ToOutputWithContext(ctx, i).(JobConditionOutput) } +func (i JobConditionArgs) ToOutput(ctx context.Context) pulumix.Output[JobCondition] { + return pulumix.Output[JobCondition]{ + OutputState: i.ToJobConditionOutputWithContext(ctx).OutputState, + } +} + // JobConditionArrayInput is an input type that accepts JobConditionArray and JobConditionArrayOutput values. // You can construct a concrete instance of `JobConditionArrayInput` via: // @@ -1518,6 +1693,12 @@ func (i JobConditionArray) ToJobConditionArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(JobConditionArrayOutput) } +func (i JobConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]JobCondition] { + return pulumix.Output[[]JobCondition]{ + OutputState: i.ToJobConditionArrayOutputWithContext(ctx).OutputState, + } +} + // JobCondition describes current state of a job. type JobConditionOutput struct{ *pulumi.OutputState } @@ -1533,6 +1714,12 @@ func (o JobConditionOutput) ToJobConditionOutputWithContext(ctx context.Context) return o } +func (o JobConditionOutput) ToOutput(ctx context.Context) pulumix.Output[JobCondition] { + return pulumix.Output[JobCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition was checked. func (o JobConditionOutput) LastProbeTime() pulumi.StringPtrOutput { return o.ApplyT(func(v JobCondition) *string { return v.LastProbeTime }).(pulumi.StringPtrOutput) @@ -1577,6 +1764,12 @@ func (o JobConditionArrayOutput) ToJobConditionArrayOutputWithContext(ctx contex return o } +func (o JobConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JobCondition] { + return pulumix.Output[[]JobCondition]{ + OutputState: o.OutputState, + } +} + func (o JobConditionArrayOutput) Index(i pulumi.IntInput) JobConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JobCondition { return vs[0].([]JobCondition)[vs[1].(int)] @@ -1638,6 +1831,12 @@ func (i JobConditionPatchArgs) ToJobConditionPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(JobConditionPatchOutput) } +func (i JobConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JobConditionPatch] { + return pulumix.Output[JobConditionPatch]{ + OutputState: i.ToJobConditionPatchOutputWithContext(ctx).OutputState, + } +} + // JobConditionPatchArrayInput is an input type that accepts JobConditionPatchArray and JobConditionPatchArrayOutput values. // You can construct a concrete instance of `JobConditionPatchArrayInput` via: // @@ -1663,6 +1862,12 @@ func (i JobConditionPatchArray) ToJobConditionPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(JobConditionPatchArrayOutput) } +func (i JobConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]JobConditionPatch] { + return pulumix.Output[[]JobConditionPatch]{ + OutputState: i.ToJobConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // JobCondition describes current state of a job. type JobConditionPatchOutput struct{ *pulumi.OutputState } @@ -1678,6 +1883,12 @@ func (o JobConditionPatchOutput) ToJobConditionPatchOutputWithContext(ctx contex return o } +func (o JobConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JobConditionPatch] { + return pulumix.Output[JobConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition was checked. func (o JobConditionPatchOutput) LastProbeTime() pulumi.StringPtrOutput { return o.ApplyT(func(v JobConditionPatch) *string { return v.LastProbeTime }).(pulumi.StringPtrOutput) @@ -1722,6 +1933,12 @@ func (o JobConditionPatchArrayOutput) ToJobConditionPatchArrayOutputWithContext( return o } +func (o JobConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]JobConditionPatch] { + return pulumix.Output[[]JobConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o JobConditionPatchArrayOutput) Index(i pulumi.IntInput) JobConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) JobConditionPatch { return vs[0].([]JobConditionPatch)[vs[1].(int)] @@ -1775,6 +1992,12 @@ func (i JobListTypeArgs) ToJobListTypeOutputWithContext(ctx context.Context) Job return pulumi.ToOutputWithContext(ctx, i).(JobListTypeOutput) } +func (i JobListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[JobListType] { + return pulumix.Output[JobListType]{ + OutputState: i.ToJobListTypeOutputWithContext(ctx).OutputState, + } +} + // JobList is a collection of jobs. type JobListTypeOutput struct{ *pulumi.OutputState } @@ -1790,6 +2013,12 @@ func (o JobListTypeOutput) ToJobListTypeOutputWithContext(ctx context.Context) J return o } +func (o JobListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[JobListType] { + return pulumix.Output[JobListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o JobListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v JobListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1901,6 +2130,12 @@ func (i JobPatchTypeArgs) ToJobPatchTypeOutputWithContext(ctx context.Context) J return pulumi.ToOutputWithContext(ctx, i).(JobPatchTypeOutput) } +func (i JobPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[JobPatchType] { + return pulumix.Output[JobPatchType]{ + OutputState: i.ToJobPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Job represents the configuration of a single job. // // This resource waits until its status is ready before registering success @@ -1936,6 +2171,12 @@ func (o JobPatchTypeOutput) ToJobPatchTypeOutputWithContext(ctx context.Context) return o } +func (o JobPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[JobPatchType] { + return pulumix.Output[JobPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o JobPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v JobPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2074,6 +2315,12 @@ func (i JobSpecArgs) ToJobSpecOutputWithContext(ctx context.Context) JobSpecOutp return pulumi.ToOutputWithContext(ctx, i).(JobSpecOutput) } +func (i JobSpecArgs) ToOutput(ctx context.Context) pulumix.Output[JobSpec] { + return pulumix.Output[JobSpec]{ + OutputState: i.ToJobSpecOutputWithContext(ctx).OutputState, + } +} + func (i JobSpecArgs) ToJobSpecPtrOutput() JobSpecPtrOutput { return i.ToJobSpecPtrOutputWithContext(context.Background()) } @@ -2115,6 +2362,12 @@ func (i *jobSpecPtrType) ToJobSpecPtrOutputWithContext(ctx context.Context) JobS return pulumi.ToOutputWithContext(ctx, i).(JobSpecPtrOutput) } +func (i *jobSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobSpec] { + return pulumix.Output[*JobSpec]{ + OutputState: i.ToJobSpecPtrOutputWithContext(ctx).OutputState, + } +} + // JobSpec describes how the job execution will look like. type JobSpecOutput struct{ *pulumi.OutputState } @@ -2140,6 +2393,12 @@ func (o JobSpecOutput) ToJobSpecPtrOutputWithContext(ctx context.Context) JobSpe }).(JobSpecPtrOutput) } +func (o JobSpecOutput) ToOutput(ctx context.Context) pulumix.Output[JobSpec] { + return pulumix.Output[JobSpec]{ + OutputState: o.OutputState, + } +} + // Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again. func (o JobSpecOutput) ActiveDeadlineSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v JobSpec) *int { return v.ActiveDeadlineSeconds }).(pulumi.IntPtrOutput) @@ -2238,6 +2497,12 @@ func (o JobSpecPtrOutput) ToJobSpecPtrOutputWithContext(ctx context.Context) Job return o } +func (o JobSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobSpec] { + return pulumix.Output[*JobSpec]{ + OutputState: o.OutputState, + } +} + func (o JobSpecPtrOutput) Elem() JobSpecOutput { return o.ApplyT(func(v *JobSpec) JobSpec { if v != nil { @@ -2515,6 +2780,12 @@ func (i JobSpecPatchArgs) ToJobSpecPatchOutputWithContext(ctx context.Context) J return pulumi.ToOutputWithContext(ctx, i).(JobSpecPatchOutput) } +func (i JobSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JobSpecPatch] { + return pulumix.Output[JobSpecPatch]{ + OutputState: i.ToJobSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i JobSpecPatchArgs) ToJobSpecPatchPtrOutput() JobSpecPatchPtrOutput { return i.ToJobSpecPatchPtrOutputWithContext(context.Background()) } @@ -2556,6 +2827,12 @@ func (i *jobSpecPatchPtrType) ToJobSpecPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(JobSpecPatchPtrOutput) } +func (i *jobSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobSpecPatch] { + return pulumix.Output[*JobSpecPatch]{ + OutputState: i.ToJobSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JobSpec describes how the job execution will look like. type JobSpecPatchOutput struct{ *pulumi.OutputState } @@ -2581,6 +2858,12 @@ func (o JobSpecPatchOutput) ToJobSpecPatchPtrOutputWithContext(ctx context.Conte }).(JobSpecPatchPtrOutput) } +func (o JobSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JobSpecPatch] { + return pulumix.Output[JobSpecPatch]{ + OutputState: o.OutputState, + } +} + // Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again. func (o JobSpecPatchOutput) ActiveDeadlineSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v JobSpecPatch) *int { return v.ActiveDeadlineSeconds }).(pulumi.IntPtrOutput) @@ -2679,6 +2962,12 @@ func (o JobSpecPatchPtrOutput) ToJobSpecPatchPtrOutputWithContext(ctx context.Co return o } +func (o JobSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobSpecPatch] { + return pulumix.Output[*JobSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o JobSpecPatchPtrOutput) Elem() JobSpecPatchOutput { return o.ApplyT(func(v *JobSpecPatch) JobSpecPatch { if v != nil { @@ -2940,6 +3229,12 @@ func (i JobStatusArgs) ToJobStatusOutputWithContext(ctx context.Context) JobStat return pulumi.ToOutputWithContext(ctx, i).(JobStatusOutput) } +func (i JobStatusArgs) ToOutput(ctx context.Context) pulumix.Output[JobStatus] { + return pulumix.Output[JobStatus]{ + OutputState: i.ToJobStatusOutputWithContext(ctx).OutputState, + } +} + func (i JobStatusArgs) ToJobStatusPtrOutput() JobStatusPtrOutput { return i.ToJobStatusPtrOutputWithContext(context.Background()) } @@ -2981,6 +3276,12 @@ func (i *jobStatusPtrType) ToJobStatusPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(JobStatusPtrOutput) } +func (i *jobStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobStatus] { + return pulumix.Output[*JobStatus]{ + OutputState: i.ToJobStatusPtrOutputWithContext(ctx).OutputState, + } +} + // JobStatus represents the current state of a Job. type JobStatusOutput struct{ *pulumi.OutputState } @@ -3006,6 +3307,12 @@ func (o JobStatusOutput) ToJobStatusPtrOutputWithContext(ctx context.Context) Jo }).(JobStatusPtrOutput) } +func (o JobStatusOutput) ToOutput(ctx context.Context) pulumix.Output[JobStatus] { + return pulumix.Output[JobStatus]{ + OutputState: o.OutputState, + } +} + // The number of pending and running pods. func (o JobStatusOutput) Active() pulumi.IntPtrOutput { return o.ApplyT(func(v JobStatus) *int { return v.Active }).(pulumi.IntPtrOutput) @@ -3086,6 +3393,12 @@ func (o JobStatusPtrOutput) ToJobStatusPtrOutputWithContext(ctx context.Context) return o } +func (o JobStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobStatus] { + return pulumix.Output[*JobStatus]{ + OutputState: o.OutputState, + } +} + func (o JobStatusPtrOutput) Elem() JobStatusOutput { return o.ApplyT(func(v *JobStatus) JobStatus { if v != nil { @@ -3314,6 +3627,12 @@ func (i JobStatusPatchArgs) ToJobStatusPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(JobStatusPatchOutput) } +func (i JobStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JobStatusPatch] { + return pulumix.Output[JobStatusPatch]{ + OutputState: i.ToJobStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i JobStatusPatchArgs) ToJobStatusPatchPtrOutput() JobStatusPatchPtrOutput { return i.ToJobStatusPatchPtrOutputWithContext(context.Background()) } @@ -3355,6 +3674,12 @@ func (i *jobStatusPatchPtrType) ToJobStatusPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(JobStatusPatchPtrOutput) } +func (i *jobStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobStatusPatch] { + return pulumix.Output[*JobStatusPatch]{ + OutputState: i.ToJobStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JobStatus represents the current state of a Job. type JobStatusPatchOutput struct{ *pulumi.OutputState } @@ -3380,6 +3705,12 @@ func (o JobStatusPatchOutput) ToJobStatusPatchPtrOutputWithContext(ctx context.C }).(JobStatusPatchPtrOutput) } +func (o JobStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JobStatusPatch] { + return pulumix.Output[JobStatusPatch]{ + OutputState: o.OutputState, + } +} + // The number of pending and running pods. func (o JobStatusPatchOutput) Active() pulumi.IntPtrOutput { return o.ApplyT(func(v JobStatusPatch) *int { return v.Active }).(pulumi.IntPtrOutput) @@ -3460,6 +3791,12 @@ func (o JobStatusPatchPtrOutput) ToJobStatusPatchPtrOutputWithContext(ctx contex return o } +func (o JobStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobStatusPatch] { + return pulumix.Output[*JobStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o JobStatusPatchPtrOutput) Elem() JobStatusPatchOutput { return o.ApplyT(func(v *JobStatusPatch) JobStatusPatch { if v != nil { @@ -3630,6 +3967,12 @@ func (i JobTemplateSpecArgs) ToJobTemplateSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecOutput) } +func (i JobTemplateSpecArgs) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpec] { + return pulumix.Output[JobTemplateSpec]{ + OutputState: i.ToJobTemplateSpecOutputWithContext(ctx).OutputState, + } +} + func (i JobTemplateSpecArgs) ToJobTemplateSpecPtrOutput() JobTemplateSpecPtrOutput { return i.ToJobTemplateSpecPtrOutputWithContext(context.Background()) } @@ -3671,6 +4014,12 @@ func (i *jobTemplateSpecPtrType) ToJobTemplateSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPtrOutput) } +func (i *jobTemplateSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpec] { + return pulumix.Output[*JobTemplateSpec]{ + OutputState: i.ToJobTemplateSpecPtrOutputWithContext(ctx).OutputState, + } +} + // JobTemplateSpec describes the data a Job should have when created from a template type JobTemplateSpecOutput struct{ *pulumi.OutputState } @@ -3696,6 +4045,12 @@ func (o JobTemplateSpecOutput) ToJobTemplateSpecPtrOutputWithContext(ctx context }).(JobTemplateSpecPtrOutput) } +func (o JobTemplateSpecOutput) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpec] { + return pulumix.Output[JobTemplateSpec]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o JobTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v JobTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -3720,6 +4075,12 @@ func (o JobTemplateSpecPtrOutput) ToJobTemplateSpecPtrOutputWithContext(ctx cont return o } +func (o JobTemplateSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpec] { + return pulumix.Output[*JobTemplateSpec]{ + OutputState: o.OutputState, + } +} + func (o JobTemplateSpecPtrOutput) Elem() JobTemplateSpecOutput { return o.ApplyT(func(v *JobTemplateSpec) JobTemplateSpec { if v != nil { @@ -3789,6 +4150,12 @@ func (i JobTemplateSpecPatchArgs) ToJobTemplateSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPatchOutput) } +func (i JobTemplateSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpecPatch] { + return pulumix.Output[JobTemplateSpecPatch]{ + OutputState: i.ToJobTemplateSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i JobTemplateSpecPatchArgs) ToJobTemplateSpecPatchPtrOutput() JobTemplateSpecPatchPtrOutput { return i.ToJobTemplateSpecPatchPtrOutputWithContext(context.Background()) } @@ -3830,6 +4197,12 @@ func (i *jobTemplateSpecPatchPtrType) ToJobTemplateSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPatchPtrOutput) } +func (i *jobTemplateSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpecPatch] { + return pulumix.Output[*JobTemplateSpecPatch]{ + OutputState: i.ToJobTemplateSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JobTemplateSpec describes the data a Job should have when created from a template type JobTemplateSpecPatchOutput struct{ *pulumi.OutputState } @@ -3855,6 +4228,12 @@ func (o JobTemplateSpecPatchOutput) ToJobTemplateSpecPatchPtrOutputWithContext(c }).(JobTemplateSpecPatchPtrOutput) } +func (o JobTemplateSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpecPatch] { + return pulumix.Output[JobTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o JobTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v JobTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -3879,6 +4258,12 @@ func (o JobTemplateSpecPatchPtrOutput) ToJobTemplateSpecPatchPtrOutputWithContex return o } +func (o JobTemplateSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpecPatch] { + return pulumix.Output[*JobTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o JobTemplateSpecPatchPtrOutput) Elem() JobTemplateSpecPatchOutput { return o.ApplyT(func(v *JobTemplateSpecPatch) JobTemplateSpecPatch { if v != nil { @@ -3944,6 +4329,12 @@ func (i PodFailurePolicyArgs) ToPodFailurePolicyOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOutput) } +func (i PodFailurePolicyArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicy] { + return pulumix.Output[PodFailurePolicy]{ + OutputState: i.ToPodFailurePolicyOutputWithContext(ctx).OutputState, + } +} + func (i PodFailurePolicyArgs) ToPodFailurePolicyPtrOutput() PodFailurePolicyPtrOutput { return i.ToPodFailurePolicyPtrOutputWithContext(context.Background()) } @@ -3985,6 +4376,12 @@ func (i *podFailurePolicyPtrType) ToPodFailurePolicyPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyPtrOutput) } +func (i *podFailurePolicyPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicy] { + return pulumix.Output[*PodFailurePolicy]{ + OutputState: i.ToPodFailurePolicyPtrOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicy describes how failed pods influence the backoffLimit. type PodFailurePolicyOutput struct{ *pulumi.OutputState } @@ -4010,6 +4407,12 @@ func (o PodFailurePolicyOutput) ToPodFailurePolicyPtrOutputWithContext(ctx conte }).(PodFailurePolicyPtrOutput) } +func (o PodFailurePolicyOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicy] { + return pulumix.Output[PodFailurePolicy]{ + OutputState: o.OutputState, + } +} + // A list of pod failure policy rules. The rules are evaluated in order. Once a rule matches a Pod failure, the remaining of the rules are ignored. When no rule matches the Pod failure, the default handling applies - the counter of pod failures is incremented and it is checked against the backoffLimit. At most 20 elements are allowed. func (o PodFailurePolicyOutput) Rules() PodFailurePolicyRuleArrayOutput { return o.ApplyT(func(v PodFailurePolicy) []PodFailurePolicyRule { return v.Rules }).(PodFailurePolicyRuleArrayOutput) @@ -4029,6 +4432,12 @@ func (o PodFailurePolicyPtrOutput) ToPodFailurePolicyPtrOutputWithContext(ctx co return o } +func (o PodFailurePolicyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicy] { + return pulumix.Output[*PodFailurePolicy]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyPtrOutput) Elem() PodFailurePolicyOutput { return o.ApplyT(func(v *PodFailurePolicy) PodFailurePolicy { if v != nil { @@ -4108,6 +4517,12 @@ func (i PodFailurePolicyOnExitCodesRequirementArgs) ToPodFailurePolicyOnExitCode return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnExitCodesRequirementOutput) } +func (i PodFailurePolicyOnExitCodesRequirementArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnExitCodesRequirement] { + return pulumix.Output[PodFailurePolicyOnExitCodesRequirement]{ + OutputState: i.ToPodFailurePolicyOnExitCodesRequirementOutputWithContext(ctx).OutputState, + } +} + func (i PodFailurePolicyOnExitCodesRequirementArgs) ToPodFailurePolicyOnExitCodesRequirementPtrOutput() PodFailurePolicyOnExitCodesRequirementPtrOutput { return i.ToPodFailurePolicyOnExitCodesRequirementPtrOutputWithContext(context.Background()) } @@ -4149,6 +4564,12 @@ func (i *podFailurePolicyOnExitCodesRequirementPtrType) ToPodFailurePolicyOnExit return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnExitCodesRequirementPtrOutput) } +func (i *podFailurePolicyOnExitCodesRequirementPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicyOnExitCodesRequirement] { + return pulumix.Output[*PodFailurePolicyOnExitCodesRequirement]{ + OutputState: i.ToPodFailurePolicyOnExitCodesRequirementPtrOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyOnExitCodesRequirement describes the requirement for handling a failed pod based on its container exit codes. In particular, it lookups the .state.terminated.exitCode for each app container and init container status, represented by the .status.containerStatuses and .status.initContainerStatuses fields in the Pod status, respectively. Containers completed with success (exit code 0) are excluded from the requirement check. type PodFailurePolicyOnExitCodesRequirementOutput struct{ *pulumi.OutputState } @@ -4174,6 +4595,12 @@ func (o PodFailurePolicyOnExitCodesRequirementOutput) ToPodFailurePolicyOnExitCo }).(PodFailurePolicyOnExitCodesRequirementPtrOutput) } +func (o PodFailurePolicyOnExitCodesRequirementOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnExitCodesRequirement] { + return pulumix.Output[PodFailurePolicyOnExitCodesRequirement]{ + OutputState: o.OutputState, + } +} + // Restricts the check for exit codes to the container with the specified name. When null, the rule applies to all containers. When specified, it should match one the container or initContainer names in the pod template. func (o PodFailurePolicyOnExitCodesRequirementOutput) ContainerName() pulumi.StringPtrOutput { return o.ApplyT(func(v PodFailurePolicyOnExitCodesRequirement) *string { return v.ContainerName }).(pulumi.StringPtrOutput) @@ -4211,6 +4638,12 @@ func (o PodFailurePolicyOnExitCodesRequirementPtrOutput) ToPodFailurePolicyOnExi return o } +func (o PodFailurePolicyOnExitCodesRequirementPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicyOnExitCodesRequirement] { + return pulumix.Output[*PodFailurePolicyOnExitCodesRequirement]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyOnExitCodesRequirementPtrOutput) Elem() PodFailurePolicyOnExitCodesRequirementOutput { return o.ApplyT(func(v *PodFailurePolicyOnExitCodesRequirement) PodFailurePolicyOnExitCodesRequirement { if v != nil { @@ -4318,6 +4751,12 @@ func (i PodFailurePolicyOnExitCodesRequirementPatchArgs) ToPodFailurePolicyOnExi return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnExitCodesRequirementPatchOutput) } +func (i PodFailurePolicyOnExitCodesRequirementPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnExitCodesRequirementPatch] { + return pulumix.Output[PodFailurePolicyOnExitCodesRequirementPatch]{ + OutputState: i.ToPodFailurePolicyOnExitCodesRequirementPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodFailurePolicyOnExitCodesRequirementPatchArgs) ToPodFailurePolicyOnExitCodesRequirementPatchPtrOutput() PodFailurePolicyOnExitCodesRequirementPatchPtrOutput { return i.ToPodFailurePolicyOnExitCodesRequirementPatchPtrOutputWithContext(context.Background()) } @@ -4359,6 +4798,12 @@ func (i *podFailurePolicyOnExitCodesRequirementPatchPtrType) ToPodFailurePolicyO return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnExitCodesRequirementPatchPtrOutput) } +func (i *podFailurePolicyOnExitCodesRequirementPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicyOnExitCodesRequirementPatch] { + return pulumix.Output[*PodFailurePolicyOnExitCodesRequirementPatch]{ + OutputState: i.ToPodFailurePolicyOnExitCodesRequirementPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyOnExitCodesRequirement describes the requirement for handling a failed pod based on its container exit codes. In particular, it lookups the .state.terminated.exitCode for each app container and init container status, represented by the .status.containerStatuses and .status.initContainerStatuses fields in the Pod status, respectively. Containers completed with success (exit code 0) are excluded from the requirement check. type PodFailurePolicyOnExitCodesRequirementPatchOutput struct{ *pulumi.OutputState } @@ -4384,6 +4829,12 @@ func (o PodFailurePolicyOnExitCodesRequirementPatchOutput) ToPodFailurePolicyOnE }).(PodFailurePolicyOnExitCodesRequirementPatchPtrOutput) } +func (o PodFailurePolicyOnExitCodesRequirementPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnExitCodesRequirementPatch] { + return pulumix.Output[PodFailurePolicyOnExitCodesRequirementPatch]{ + OutputState: o.OutputState, + } +} + // Restricts the check for exit codes to the container with the specified name. When null, the rule applies to all containers. When specified, it should match one the container or initContainer names in the pod template. func (o PodFailurePolicyOnExitCodesRequirementPatchOutput) ContainerName() pulumi.StringPtrOutput { return o.ApplyT(func(v PodFailurePolicyOnExitCodesRequirementPatch) *string { return v.ContainerName }).(pulumi.StringPtrOutput) @@ -4421,6 +4872,12 @@ func (o PodFailurePolicyOnExitCodesRequirementPatchPtrOutput) ToPodFailurePolicy return o } +func (o PodFailurePolicyOnExitCodesRequirementPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicyOnExitCodesRequirementPatch] { + return pulumix.Output[*PodFailurePolicyOnExitCodesRequirementPatch]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyOnExitCodesRequirementPatchPtrOutput) Elem() PodFailurePolicyOnExitCodesRequirementPatchOutput { return o.ApplyT(func(v *PodFailurePolicyOnExitCodesRequirementPatch) PodFailurePolicyOnExitCodesRequirementPatch { if v != nil { @@ -4508,6 +4965,12 @@ func (i PodFailurePolicyOnPodConditionsPatternArgs) ToPodFailurePolicyOnPodCondi return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnPodConditionsPatternOutput) } +func (i PodFailurePolicyOnPodConditionsPatternArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnPodConditionsPattern] { + return pulumix.Output[PodFailurePolicyOnPodConditionsPattern]{ + OutputState: i.ToPodFailurePolicyOnPodConditionsPatternOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyOnPodConditionsPatternArrayInput is an input type that accepts PodFailurePolicyOnPodConditionsPatternArray and PodFailurePolicyOnPodConditionsPatternArrayOutput values. // You can construct a concrete instance of `PodFailurePolicyOnPodConditionsPatternArrayInput` via: // @@ -4533,6 +4996,12 @@ func (i PodFailurePolicyOnPodConditionsPatternArray) ToPodFailurePolicyOnPodCond return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnPodConditionsPatternArrayOutput) } +func (i PodFailurePolicyOnPodConditionsPatternArray) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyOnPodConditionsPattern] { + return pulumix.Output[[]PodFailurePolicyOnPodConditionsPattern]{ + OutputState: i.ToPodFailurePolicyOnPodConditionsPatternArrayOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyOnPodConditionsPattern describes a pattern for matching an actual pod condition type. type PodFailurePolicyOnPodConditionsPatternOutput struct{ *pulumi.OutputState } @@ -4548,6 +5017,12 @@ func (o PodFailurePolicyOnPodConditionsPatternOutput) ToPodFailurePolicyOnPodCon return o } +func (o PodFailurePolicyOnPodConditionsPatternOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnPodConditionsPattern] { + return pulumix.Output[PodFailurePolicyOnPodConditionsPattern]{ + OutputState: o.OutputState, + } +} + // Specifies the required Pod condition status. To match a pod condition it is required that the specified status equals the pod condition status. Defaults to True. func (o PodFailurePolicyOnPodConditionsPatternOutput) Status() pulumi.StringOutput { return o.ApplyT(func(v PodFailurePolicyOnPodConditionsPattern) string { return v.Status }).(pulumi.StringOutput) @@ -4572,6 +5047,12 @@ func (o PodFailurePolicyOnPodConditionsPatternArrayOutput) ToPodFailurePolicyOnP return o } +func (o PodFailurePolicyOnPodConditionsPatternArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyOnPodConditionsPattern] { + return pulumix.Output[[]PodFailurePolicyOnPodConditionsPattern]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyOnPodConditionsPatternArrayOutput) Index(i pulumi.IntInput) PodFailurePolicyOnPodConditionsPatternOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodFailurePolicyOnPodConditionsPattern { return vs[0].([]PodFailurePolicyOnPodConditionsPattern)[vs[1].(int)] @@ -4617,6 +5098,12 @@ func (i PodFailurePolicyOnPodConditionsPatternPatchArgs) ToPodFailurePolicyOnPod return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnPodConditionsPatternPatchOutput) } +func (i PodFailurePolicyOnPodConditionsPatternPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnPodConditionsPatternPatch] { + return pulumix.Output[PodFailurePolicyOnPodConditionsPatternPatch]{ + OutputState: i.ToPodFailurePolicyOnPodConditionsPatternPatchOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyOnPodConditionsPatternPatchArrayInput is an input type that accepts PodFailurePolicyOnPodConditionsPatternPatchArray and PodFailurePolicyOnPodConditionsPatternPatchArrayOutput values. // You can construct a concrete instance of `PodFailurePolicyOnPodConditionsPatternPatchArrayInput` via: // @@ -4642,6 +5129,12 @@ func (i PodFailurePolicyOnPodConditionsPatternPatchArray) ToPodFailurePolicyOnPo return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyOnPodConditionsPatternPatchArrayOutput) } +func (i PodFailurePolicyOnPodConditionsPatternPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyOnPodConditionsPatternPatch] { + return pulumix.Output[[]PodFailurePolicyOnPodConditionsPatternPatch]{ + OutputState: i.ToPodFailurePolicyOnPodConditionsPatternPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyOnPodConditionsPattern describes a pattern for matching an actual pod condition type. type PodFailurePolicyOnPodConditionsPatternPatchOutput struct{ *pulumi.OutputState } @@ -4657,6 +5150,12 @@ func (o PodFailurePolicyOnPodConditionsPatternPatchOutput) ToPodFailurePolicyOnP return o } +func (o PodFailurePolicyOnPodConditionsPatternPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyOnPodConditionsPatternPatch] { + return pulumix.Output[PodFailurePolicyOnPodConditionsPatternPatch]{ + OutputState: o.OutputState, + } +} + // Specifies the required Pod condition status. To match a pod condition it is required that the specified status equals the pod condition status. Defaults to True. func (o PodFailurePolicyOnPodConditionsPatternPatchOutput) Status() pulumi.StringPtrOutput { return o.ApplyT(func(v PodFailurePolicyOnPodConditionsPatternPatch) *string { return v.Status }).(pulumi.StringPtrOutput) @@ -4681,6 +5180,12 @@ func (o PodFailurePolicyOnPodConditionsPatternPatchArrayOutput) ToPodFailurePoli return o } +func (o PodFailurePolicyOnPodConditionsPatternPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyOnPodConditionsPatternPatch] { + return pulumix.Output[[]PodFailurePolicyOnPodConditionsPatternPatch]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyOnPodConditionsPatternPatchArrayOutput) Index(i pulumi.IntInput) PodFailurePolicyOnPodConditionsPatternPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodFailurePolicyOnPodConditionsPatternPatch { return vs[0].([]PodFailurePolicyOnPodConditionsPatternPatch)[vs[1].(int)] @@ -4722,6 +5227,12 @@ func (i PodFailurePolicyPatchArgs) ToPodFailurePolicyPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyPatchOutput) } +func (i PodFailurePolicyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyPatch] { + return pulumix.Output[PodFailurePolicyPatch]{ + OutputState: i.ToPodFailurePolicyPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodFailurePolicyPatchArgs) ToPodFailurePolicyPatchPtrOutput() PodFailurePolicyPatchPtrOutput { return i.ToPodFailurePolicyPatchPtrOutputWithContext(context.Background()) } @@ -4763,6 +5274,12 @@ func (i *podFailurePolicyPatchPtrType) ToPodFailurePolicyPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyPatchPtrOutput) } +func (i *podFailurePolicyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicyPatch] { + return pulumix.Output[*PodFailurePolicyPatch]{ + OutputState: i.ToPodFailurePolicyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicy describes how failed pods influence the backoffLimit. type PodFailurePolicyPatchOutput struct{ *pulumi.OutputState } @@ -4788,6 +5305,12 @@ func (o PodFailurePolicyPatchOutput) ToPodFailurePolicyPatchPtrOutputWithContext }).(PodFailurePolicyPatchPtrOutput) } +func (o PodFailurePolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyPatch] { + return pulumix.Output[PodFailurePolicyPatch]{ + OutputState: o.OutputState, + } +} + // A list of pod failure policy rules. The rules are evaluated in order. Once a rule matches a Pod failure, the remaining of the rules are ignored. When no rule matches the Pod failure, the default handling applies - the counter of pod failures is incremented and it is checked against the backoffLimit. At most 20 elements are allowed. func (o PodFailurePolicyPatchOutput) Rules() PodFailurePolicyRulePatchArrayOutput { return o.ApplyT(func(v PodFailurePolicyPatch) []PodFailurePolicyRulePatch { return v.Rules }).(PodFailurePolicyRulePatchArrayOutput) @@ -4807,6 +5330,12 @@ func (o PodFailurePolicyPatchPtrOutput) ToPodFailurePolicyPatchPtrOutputWithCont return o } +func (o PodFailurePolicyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodFailurePolicyPatch] { + return pulumix.Output[*PodFailurePolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyPatchPtrOutput) Elem() PodFailurePolicyPatchOutput { return o.ApplyT(func(v *PodFailurePolicyPatch) PodFailurePolicyPatch { if v != nil { @@ -4894,6 +5423,12 @@ func (i PodFailurePolicyRuleArgs) ToPodFailurePolicyRuleOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyRuleOutput) } +func (i PodFailurePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyRule] { + return pulumix.Output[PodFailurePolicyRule]{ + OutputState: i.ToPodFailurePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyRuleArrayInput is an input type that accepts PodFailurePolicyRuleArray and PodFailurePolicyRuleArrayOutput values. // You can construct a concrete instance of `PodFailurePolicyRuleArrayInput` via: // @@ -4919,6 +5454,12 @@ func (i PodFailurePolicyRuleArray) ToPodFailurePolicyRuleArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyRuleArrayOutput) } +func (i PodFailurePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyRule] { + return pulumix.Output[[]PodFailurePolicyRule]{ + OutputState: i.ToPodFailurePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyRule describes how a pod failure is handled when the requirements are met. One of onExitCodes and onPodConditions, but not both, can be used in each rule. type PodFailurePolicyRuleOutput struct{ *pulumi.OutputState } @@ -4934,6 +5475,12 @@ func (o PodFailurePolicyRuleOutput) ToPodFailurePolicyRuleOutputWithContext(ctx return o } +func (o PodFailurePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyRule] { + return pulumix.Output[PodFailurePolicyRule]{ + OutputState: o.OutputState, + } +} + // Specifies the action taken on a pod failure when the requirements are satisfied. Possible values are: // // - FailJob: indicates that the pod's job is marked as Failed and all @@ -4975,6 +5522,12 @@ func (o PodFailurePolicyRuleArrayOutput) ToPodFailurePolicyRuleArrayOutputWithCo return o } +func (o PodFailurePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyRule] { + return pulumix.Output[[]PodFailurePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyRuleArrayOutput) Index(i pulumi.IntInput) PodFailurePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodFailurePolicyRule { return vs[0].([]PodFailurePolicyRule)[vs[1].(int)] @@ -5048,6 +5601,12 @@ func (i PodFailurePolicyRulePatchArgs) ToPodFailurePolicyRulePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyRulePatchOutput) } +func (i PodFailurePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyRulePatch] { + return pulumix.Output[PodFailurePolicyRulePatch]{ + OutputState: i.ToPodFailurePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyRulePatchArrayInput is an input type that accepts PodFailurePolicyRulePatchArray and PodFailurePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `PodFailurePolicyRulePatchArrayInput` via: // @@ -5073,6 +5632,12 @@ func (i PodFailurePolicyRulePatchArray) ToPodFailurePolicyRulePatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodFailurePolicyRulePatchArrayOutput) } +func (i PodFailurePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyRulePatch] { + return pulumix.Output[[]PodFailurePolicyRulePatch]{ + OutputState: i.ToPodFailurePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodFailurePolicyRule describes how a pod failure is handled when the requirements are met. One of onExitCodes and onPodConditions, but not both, can be used in each rule. type PodFailurePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -5088,6 +5653,12 @@ func (o PodFailurePolicyRulePatchOutput) ToPodFailurePolicyRulePatchOutputWithCo return o } +func (o PodFailurePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodFailurePolicyRulePatch] { + return pulumix.Output[PodFailurePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // Specifies the action taken on a pod failure when the requirements are satisfied. Possible values are: // // - FailJob: indicates that the pod's job is marked as Failed and all @@ -5131,6 +5702,12 @@ func (o PodFailurePolicyRulePatchArrayOutput) ToPodFailurePolicyRulePatchArrayOu return o } +func (o PodFailurePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodFailurePolicyRulePatch] { + return pulumix.Output[[]PodFailurePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o PodFailurePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) PodFailurePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodFailurePolicyRulePatch { return vs[0].([]PodFailurePolicyRulePatch)[vs[1].(int)] @@ -5176,6 +5753,12 @@ func (i UncountedTerminatedPodsArgs) ToUncountedTerminatedPodsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(UncountedTerminatedPodsOutput) } +func (i UncountedTerminatedPodsArgs) ToOutput(ctx context.Context) pulumix.Output[UncountedTerminatedPods] { + return pulumix.Output[UncountedTerminatedPods]{ + OutputState: i.ToUncountedTerminatedPodsOutputWithContext(ctx).OutputState, + } +} + func (i UncountedTerminatedPodsArgs) ToUncountedTerminatedPodsPtrOutput() UncountedTerminatedPodsPtrOutput { return i.ToUncountedTerminatedPodsPtrOutputWithContext(context.Background()) } @@ -5217,6 +5800,12 @@ func (i *uncountedTerminatedPodsPtrType) ToUncountedTerminatedPodsPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(UncountedTerminatedPodsPtrOutput) } +func (i *uncountedTerminatedPodsPtrType) ToOutput(ctx context.Context) pulumix.Output[*UncountedTerminatedPods] { + return pulumix.Output[*UncountedTerminatedPods]{ + OutputState: i.ToUncountedTerminatedPodsPtrOutputWithContext(ctx).OutputState, + } +} + // UncountedTerminatedPods holds UIDs of Pods that have terminated but haven't been accounted in Job status counters. type UncountedTerminatedPodsOutput struct{ *pulumi.OutputState } @@ -5242,6 +5831,12 @@ func (o UncountedTerminatedPodsOutput) ToUncountedTerminatedPodsPtrOutputWithCon }).(UncountedTerminatedPodsPtrOutput) } +func (o UncountedTerminatedPodsOutput) ToOutput(ctx context.Context) pulumix.Output[UncountedTerminatedPods] { + return pulumix.Output[UncountedTerminatedPods]{ + OutputState: o.OutputState, + } +} + // failed holds UIDs of failed Pods. func (o UncountedTerminatedPodsOutput) Failed() pulumi.StringArrayOutput { return o.ApplyT(func(v UncountedTerminatedPods) []string { return v.Failed }).(pulumi.StringArrayOutput) @@ -5266,6 +5861,12 @@ func (o UncountedTerminatedPodsPtrOutput) ToUncountedTerminatedPodsPtrOutputWith return o } +func (o UncountedTerminatedPodsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UncountedTerminatedPods] { + return pulumix.Output[*UncountedTerminatedPods]{ + OutputState: o.OutputState, + } +} + func (o UncountedTerminatedPodsPtrOutput) Elem() UncountedTerminatedPodsOutput { return o.ApplyT(func(v *UncountedTerminatedPods) UncountedTerminatedPods { if v != nil { @@ -5335,6 +5936,12 @@ func (i UncountedTerminatedPodsPatchArgs) ToUncountedTerminatedPodsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(UncountedTerminatedPodsPatchOutput) } +func (i UncountedTerminatedPodsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UncountedTerminatedPodsPatch] { + return pulumix.Output[UncountedTerminatedPodsPatch]{ + OutputState: i.ToUncountedTerminatedPodsPatchOutputWithContext(ctx).OutputState, + } +} + func (i UncountedTerminatedPodsPatchArgs) ToUncountedTerminatedPodsPatchPtrOutput() UncountedTerminatedPodsPatchPtrOutput { return i.ToUncountedTerminatedPodsPatchPtrOutputWithContext(context.Background()) } @@ -5376,6 +5983,12 @@ func (i *uncountedTerminatedPodsPatchPtrType) ToUncountedTerminatedPodsPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(UncountedTerminatedPodsPatchPtrOutput) } +func (i *uncountedTerminatedPodsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UncountedTerminatedPodsPatch] { + return pulumix.Output[*UncountedTerminatedPodsPatch]{ + OutputState: i.ToUncountedTerminatedPodsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UncountedTerminatedPods holds UIDs of Pods that have terminated but haven't been accounted in Job status counters. type UncountedTerminatedPodsPatchOutput struct{ *pulumi.OutputState } @@ -5401,6 +6014,12 @@ func (o UncountedTerminatedPodsPatchOutput) ToUncountedTerminatedPodsPatchPtrOut }).(UncountedTerminatedPodsPatchPtrOutput) } +func (o UncountedTerminatedPodsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UncountedTerminatedPodsPatch] { + return pulumix.Output[UncountedTerminatedPodsPatch]{ + OutputState: o.OutputState, + } +} + // failed holds UIDs of failed Pods. func (o UncountedTerminatedPodsPatchOutput) Failed() pulumi.StringArrayOutput { return o.ApplyT(func(v UncountedTerminatedPodsPatch) []string { return v.Failed }).(pulumi.StringArrayOutput) @@ -5425,6 +6044,12 @@ func (o UncountedTerminatedPodsPatchPtrOutput) ToUncountedTerminatedPodsPatchPtr return o } +func (o UncountedTerminatedPodsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UncountedTerminatedPodsPatch] { + return pulumix.Output[*UncountedTerminatedPodsPatch]{ + OutputState: o.OutputState, + } +} + func (o UncountedTerminatedPodsPatchPtrOutput) Elem() UncountedTerminatedPodsPatchOutput { return o.ApplyT(func(v *UncountedTerminatedPodsPatch) UncountedTerminatedPodsPatch { if v != nil { diff --git a/sdk/go/kubernetes/batch/v1beta1/cronJob.go b/sdk/go/kubernetes/batch/v1beta1/cronJob.go index eae3d9ab3c..5c3bbd4c75 100644 --- a/sdk/go/kubernetes/batch/v1beta1/cronJob.go +++ b/sdk/go/kubernetes/batch/v1beta1/cronJob.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CronJob represents the configuration of a single cron job. @@ -124,6 +125,12 @@ func (i *CronJob) ToCronJobOutputWithContext(ctx context.Context) CronJobOutput return pulumi.ToOutputWithContext(ctx, i).(CronJobOutput) } +func (i *CronJob) ToOutput(ctx context.Context) pulumix.Output[*CronJob] { + return pulumix.Output[*CronJob]{ + OutputState: i.ToCronJobOutputWithContext(ctx).OutputState, + } +} + // CronJobArrayInput is an input type that accepts CronJobArray and CronJobArrayOutput values. // You can construct a concrete instance of `CronJobArrayInput` via: // @@ -149,6 +156,12 @@ func (i CronJobArray) ToCronJobArrayOutputWithContext(ctx context.Context) CronJ return pulumi.ToOutputWithContext(ctx, i).(CronJobArrayOutput) } +func (i CronJobArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJob] { + return pulumix.Output[[]*CronJob]{ + OutputState: i.ToCronJobArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobMapInput is an input type that accepts CronJobMap and CronJobMapOutput values. // You can construct a concrete instance of `CronJobMapInput` via: // @@ -174,6 +187,12 @@ func (i CronJobMap) ToCronJobMapOutputWithContext(ctx context.Context) CronJobMa return pulumi.ToOutputWithContext(ctx, i).(CronJobMapOutput) } +func (i CronJobMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJob] { + return pulumix.Output[map[string]*CronJob]{ + OutputState: i.ToCronJobMapOutputWithContext(ctx).OutputState, + } +} + type CronJobOutput struct{ *pulumi.OutputState } func (CronJobOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o CronJobOutput) ToCronJobOutputWithContext(ctx context.Context) CronJobOu return o } +func (o CronJobOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJob] { + return pulumix.Output[*CronJob]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CronJob) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -227,6 +252,12 @@ func (o CronJobArrayOutput) ToCronJobArrayOutputWithContext(ctx context.Context) return o } +func (o CronJobArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJob] { + return pulumix.Output[[]*CronJob]{ + OutputState: o.OutputState, + } +} + func (o CronJobArrayOutput) Index(i pulumi.IntInput) CronJobOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJob { return vs[0].([]*CronJob)[vs[1].(int)] @@ -247,6 +278,12 @@ func (o CronJobMapOutput) ToCronJobMapOutputWithContext(ctx context.Context) Cro return o } +func (o CronJobMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJob] { + return pulumix.Output[map[string]*CronJob]{ + OutputState: o.OutputState, + } +} + func (o CronJobMapOutput) MapIndex(k pulumi.StringInput) CronJobOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJob { return vs[0].(map[string]*CronJob)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1beta1/cronJobList.go b/sdk/go/kubernetes/batch/v1beta1/cronJobList.go index 1d6a06b007..39b4a997e2 100644 --- a/sdk/go/kubernetes/batch/v1beta1/cronJobList.go +++ b/sdk/go/kubernetes/batch/v1beta1/cronJobList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CronJobList is a collection of cron jobs. @@ -117,6 +118,12 @@ func (i *CronJobList) ToCronJobListOutputWithContext(ctx context.Context) CronJo return pulumi.ToOutputWithContext(ctx, i).(CronJobListOutput) } +func (i *CronJobList) ToOutput(ctx context.Context) pulumix.Output[*CronJobList] { + return pulumix.Output[*CronJobList]{ + OutputState: i.ToCronJobListOutputWithContext(ctx).OutputState, + } +} + // CronJobListArrayInput is an input type that accepts CronJobListArray and CronJobListArrayOutput values. // You can construct a concrete instance of `CronJobListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CronJobListArray) ToCronJobListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CronJobListArrayOutput) } +func (i CronJobListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobList] { + return pulumix.Output[[]*CronJobList]{ + OutputState: i.ToCronJobListArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobListMapInput is an input type that accepts CronJobListMap and CronJobListMapOutput values. // You can construct a concrete instance of `CronJobListMapInput` via: // @@ -167,6 +180,12 @@ func (i CronJobListMap) ToCronJobListMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CronJobListMapOutput) } +func (i CronJobListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobList] { + return pulumix.Output[map[string]*CronJobList]{ + OutputState: i.ToCronJobListMapOutputWithContext(ctx).OutputState, + } +} + type CronJobListOutput struct{ *pulumi.OutputState } func (CronJobListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CronJobListOutput) ToCronJobListOutputWithContext(ctx context.Context) C return o } +func (o CronJobListOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobList] { + return pulumix.Output[*CronJobList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CronJobList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CronJobListArrayOutput) ToCronJobListArrayOutputWithContext(ctx context. return o } +func (o CronJobListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobList] { + return pulumix.Output[[]*CronJobList]{ + OutputState: o.OutputState, + } +} + func (o CronJobListArrayOutput) Index(i pulumi.IntInput) CronJobListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJobList { return vs[0].([]*CronJobList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CronJobListMapOutput) ToCronJobListMapOutputWithContext(ctx context.Cont return o } +func (o CronJobListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobList] { + return pulumix.Output[map[string]*CronJobList]{ + OutputState: o.OutputState, + } +} + func (o CronJobListMapOutput) MapIndex(k pulumi.StringInput) CronJobListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJobList { return vs[0].(map[string]*CronJobList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1beta1/cronJobPatch.go b/sdk/go/kubernetes/batch/v1beta1/cronJobPatch.go index 86a4d5a385..9fd1042f97 100644 --- a/sdk/go/kubernetes/batch/v1beta1/cronJobPatch.go +++ b/sdk/go/kubernetes/batch/v1beta1/cronJobPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *CronJobPatch) ToCronJobPatchOutputWithContext(ctx context.Context) Cron return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchOutput) } +func (i *CronJobPatch) ToOutput(ctx context.Context) pulumix.Output[*CronJobPatch] { + return pulumix.Output[*CronJobPatch]{ + OutputState: i.ToCronJobPatchOutputWithContext(ctx).OutputState, + } +} + // CronJobPatchArrayInput is an input type that accepts CronJobPatchArray and CronJobPatchArrayOutput values. // You can construct a concrete instance of `CronJobPatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i CronJobPatchArray) ToCronJobPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchArrayOutput) } +func (i CronJobPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobPatch] { + return pulumix.Output[[]*CronJobPatch]{ + OutputState: i.ToCronJobPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobPatchMapInput is an input type that accepts CronJobPatchMap and CronJobPatchMapOutput values. // You can construct a concrete instance of `CronJobPatchMapInput` via: // @@ -180,6 +193,12 @@ func (i CronJobPatchMap) ToCronJobPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchMapOutput) } +func (i CronJobPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobPatch] { + return pulumix.Output[map[string]*CronJobPatch]{ + OutputState: i.ToCronJobPatchMapOutputWithContext(ctx).OutputState, + } +} + type CronJobPatchOutput struct{ *pulumi.OutputState } func (CronJobPatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o CronJobPatchOutput) ToCronJobPatchOutputWithContext(ctx context.Context) return o } +func (o CronJobPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobPatch] { + return pulumix.Output[*CronJobPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CronJobPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -233,6 +258,12 @@ func (o CronJobPatchArrayOutput) ToCronJobPatchArrayOutputWithContext(ctx contex return o } +func (o CronJobPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobPatch] { + return pulumix.Output[[]*CronJobPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobPatchArrayOutput) Index(i pulumi.IntInput) CronJobPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJobPatch { return vs[0].([]*CronJobPatch)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o CronJobPatchMapOutput) ToCronJobPatchMapOutputWithContext(ctx context.Co return o } +func (o CronJobPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobPatch] { + return pulumix.Output[map[string]*CronJobPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobPatchMapOutput) MapIndex(k pulumi.StringInput) CronJobPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJobPatch { return vs[0].(map[string]*CronJobPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/batch/v1beta1/pulumiTypes.go index 2e3b6a7460..5d318572e8 100644 --- a/sdk/go/kubernetes/batch/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/batch/v1beta1/pulumiTypes.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -67,6 +68,12 @@ func (i CronJobTypeArgs) ToCronJobTypeOutputWithContext(ctx context.Context) Cro return pulumi.ToOutputWithContext(ctx, i).(CronJobTypeOutput) } +func (i CronJobTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobType] { + return pulumix.Output[CronJobType]{ + OutputState: i.ToCronJobTypeOutputWithContext(ctx).OutputState, + } +} + // CronJobTypeArrayInput is an input type that accepts CronJobTypeArray and CronJobTypeArrayOutput values. // You can construct a concrete instance of `CronJobTypeArrayInput` via: // @@ -92,6 +99,12 @@ func (i CronJobTypeArray) ToCronJobTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CronJobTypeArrayOutput) } +func (i CronJobTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CronJobType] { + return pulumix.Output[[]CronJobType]{ + OutputState: i.ToCronJobTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CronJob represents the configuration of a single cron job. type CronJobTypeOutput struct{ *pulumi.OutputState } @@ -107,6 +120,12 @@ func (o CronJobTypeOutput) ToCronJobTypeOutputWithContext(ctx context.Context) C return o } +func (o CronJobTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobType] { + return pulumix.Output[CronJobType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -146,6 +165,12 @@ func (o CronJobTypeArrayOutput) ToCronJobTypeArrayOutputWithContext(ctx context. return o } +func (o CronJobTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CronJobType] { + return pulumix.Output[[]CronJobType]{ + OutputState: o.OutputState, + } +} + func (o CronJobTypeArrayOutput) Index(i pulumi.IntInput) CronJobTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CronJobType { return vs[0].([]CronJobType)[vs[1].(int)] @@ -199,6 +224,12 @@ func (i CronJobListTypeArgs) ToCronJobListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CronJobListTypeOutput) } +func (i CronJobListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobListType] { + return pulumix.Output[CronJobListType]{ + OutputState: i.ToCronJobListTypeOutputWithContext(ctx).OutputState, + } +} + // CronJobList is a collection of cron jobs. type CronJobListTypeOutput struct{ *pulumi.OutputState } @@ -214,6 +245,12 @@ func (o CronJobListTypeOutput) ToCronJobListTypeOutputWithContext(ctx context.Co return o } +func (o CronJobListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobListType] { + return pulumix.Output[CronJobListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -285,6 +322,12 @@ func (i CronJobPatchTypeArgs) ToCronJobPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchTypeOutput) } +func (i CronJobPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobPatchType] { + return pulumix.Output[CronJobPatchType]{ + OutputState: i.ToCronJobPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CronJob represents the configuration of a single cron job. type CronJobPatchTypeOutput struct{ *pulumi.OutputState } @@ -300,6 +343,12 @@ func (o CronJobPatchTypeOutput) ToCronJobPatchTypeOutputWithContext(ctx context. return o } +func (o CronJobPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobPatchType] { + return pulumix.Output[CronJobPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -384,6 +433,12 @@ func (i CronJobSpecArgs) ToCronJobSpecOutputWithContext(ctx context.Context) Cro return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecOutput) } +func (i CronJobSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobSpec] { + return pulumix.Output[CronJobSpec]{ + OutputState: i.ToCronJobSpecOutputWithContext(ctx).OutputState, + } +} + func (i CronJobSpecArgs) ToCronJobSpecPtrOutput() CronJobSpecPtrOutput { return i.ToCronJobSpecPtrOutputWithContext(context.Background()) } @@ -425,6 +480,12 @@ func (i *cronJobSpecPtrType) ToCronJobSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPtrOutput) } +func (i *cronJobSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpec] { + return pulumix.Output[*CronJobSpec]{ + OutputState: i.ToCronJobSpecPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobSpec describes how the job execution will look like and when it will actually run. type CronJobSpecOutput struct{ *pulumi.OutputState } @@ -450,6 +511,12 @@ func (o CronJobSpecOutput) ToCronJobSpecPtrOutputWithContext(ctx context.Context }).(CronJobSpecPtrOutput) } +func (o CronJobSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobSpec] { + return pulumix.Output[CronJobSpec]{ + OutputState: o.OutputState, + } +} + // Specifies how to treat concurrent executions of a Job. Valid values are: - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one func (o CronJobSpecOutput) ConcurrencyPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobSpec) *string { return v.ConcurrencyPolicy }).(pulumi.StringPtrOutput) @@ -499,6 +566,12 @@ func (o CronJobSpecPtrOutput) ToCronJobSpecPtrOutputWithContext(ctx context.Cont return o } +func (o CronJobSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpec] { + return pulumix.Output[*CronJobSpec]{ + OutputState: o.OutputState, + } +} + func (o CronJobSpecPtrOutput) Elem() CronJobSpecOutput { return o.ApplyT(func(v *CronJobSpec) CronJobSpec { if v != nil { @@ -638,6 +711,12 @@ func (i CronJobSpecPatchArgs) ToCronJobSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPatchOutput) } +func (i CronJobSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobSpecPatch] { + return pulumix.Output[CronJobSpecPatch]{ + OutputState: i.ToCronJobSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CronJobSpecPatchArgs) ToCronJobSpecPatchPtrOutput() CronJobSpecPatchPtrOutput { return i.ToCronJobSpecPatchPtrOutputWithContext(context.Background()) } @@ -679,6 +758,12 @@ func (i *cronJobSpecPatchPtrType) ToCronJobSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPatchPtrOutput) } +func (i *cronJobSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpecPatch] { + return pulumix.Output[*CronJobSpecPatch]{ + OutputState: i.ToCronJobSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobSpec describes how the job execution will look like and when it will actually run. type CronJobSpecPatchOutput struct{ *pulumi.OutputState } @@ -704,6 +789,12 @@ func (o CronJobSpecPatchOutput) ToCronJobSpecPatchPtrOutputWithContext(ctx conte }).(CronJobSpecPatchPtrOutput) } +func (o CronJobSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobSpecPatch] { + return pulumix.Output[CronJobSpecPatch]{ + OutputState: o.OutputState, + } +} + // Specifies how to treat concurrent executions of a Job. Valid values are: - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one func (o CronJobSpecPatchOutput) ConcurrencyPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobSpecPatch) *string { return v.ConcurrencyPolicy }).(pulumi.StringPtrOutput) @@ -753,6 +844,12 @@ func (o CronJobSpecPatchPtrOutput) ToCronJobSpecPatchPtrOutputWithContext(ctx co return o } +func (o CronJobSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpecPatch] { + return pulumix.Output[*CronJobSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobSpecPatchPtrOutput) Elem() CronJobSpecPatchOutput { return o.ApplyT(func(v *CronJobSpecPatch) CronJobSpecPatch { if v != nil { @@ -872,6 +969,12 @@ func (i CronJobStatusArgs) ToCronJobStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusOutput) } +func (i CronJobStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobStatus] { + return pulumix.Output[CronJobStatus]{ + OutputState: i.ToCronJobStatusOutputWithContext(ctx).OutputState, + } +} + func (i CronJobStatusArgs) ToCronJobStatusPtrOutput() CronJobStatusPtrOutput { return i.ToCronJobStatusPtrOutputWithContext(context.Background()) } @@ -913,6 +1016,12 @@ func (i *cronJobStatusPtrType) ToCronJobStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPtrOutput) } +func (i *cronJobStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatus] { + return pulumix.Output[*CronJobStatus]{ + OutputState: i.ToCronJobStatusPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobStatus represents the current state of a cron job. type CronJobStatusOutput struct{ *pulumi.OutputState } @@ -938,6 +1047,12 @@ func (o CronJobStatusOutput) ToCronJobStatusPtrOutputWithContext(ctx context.Con }).(CronJobStatusPtrOutput) } +func (o CronJobStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobStatus] { + return pulumix.Output[CronJobStatus]{ + OutputState: o.OutputState, + } +} + // A list of pointers to currently running jobs. func (o CronJobStatusOutput) Active() corev1.ObjectReferenceArrayOutput { return o.ApplyT(func(v CronJobStatus) []corev1.ObjectReference { return v.Active }).(corev1.ObjectReferenceArrayOutput) @@ -962,6 +1077,12 @@ func (o CronJobStatusPtrOutput) ToCronJobStatusPtrOutputWithContext(ctx context. return o } +func (o CronJobStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatus] { + return pulumix.Output[*CronJobStatus]{ + OutputState: o.OutputState, + } +} + func (o CronJobStatusPtrOutput) Elem() CronJobStatusOutput { return o.ApplyT(func(v *CronJobStatus) CronJobStatus { if v != nil { @@ -1031,6 +1152,12 @@ func (i CronJobStatusPatchArgs) ToCronJobStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPatchOutput) } +func (i CronJobStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobStatusPatch] { + return pulumix.Output[CronJobStatusPatch]{ + OutputState: i.ToCronJobStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CronJobStatusPatchArgs) ToCronJobStatusPatchPtrOutput() CronJobStatusPatchPtrOutput { return i.ToCronJobStatusPatchPtrOutputWithContext(context.Background()) } @@ -1072,6 +1199,12 @@ func (i *cronJobStatusPatchPtrType) ToCronJobStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPatchPtrOutput) } +func (i *cronJobStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatusPatch] { + return pulumix.Output[*CronJobStatusPatch]{ + OutputState: i.ToCronJobStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobStatus represents the current state of a cron job. type CronJobStatusPatchOutput struct{ *pulumi.OutputState } @@ -1097,6 +1230,12 @@ func (o CronJobStatusPatchOutput) ToCronJobStatusPatchPtrOutputWithContext(ctx c }).(CronJobStatusPatchPtrOutput) } +func (o CronJobStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobStatusPatch] { + return pulumix.Output[CronJobStatusPatch]{ + OutputState: o.OutputState, + } +} + // A list of pointers to currently running jobs. func (o CronJobStatusPatchOutput) Active() corev1.ObjectReferencePatchArrayOutput { return o.ApplyT(func(v CronJobStatusPatch) []corev1.ObjectReferencePatch { return v.Active }).(corev1.ObjectReferencePatchArrayOutput) @@ -1121,6 +1260,12 @@ func (o CronJobStatusPatchPtrOutput) ToCronJobStatusPatchPtrOutputWithContext(ct return o } +func (o CronJobStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatusPatch] { + return pulumix.Output[*CronJobStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobStatusPatchPtrOutput) Elem() CronJobStatusPatchOutput { return o.ApplyT(func(v *CronJobStatusPatch) CronJobStatusPatch { if v != nil { @@ -1190,6 +1335,12 @@ func (i JobTemplateSpecArgs) ToJobTemplateSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecOutput) } +func (i JobTemplateSpecArgs) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpec] { + return pulumix.Output[JobTemplateSpec]{ + OutputState: i.ToJobTemplateSpecOutputWithContext(ctx).OutputState, + } +} + func (i JobTemplateSpecArgs) ToJobTemplateSpecPtrOutput() JobTemplateSpecPtrOutput { return i.ToJobTemplateSpecPtrOutputWithContext(context.Background()) } @@ -1231,6 +1382,12 @@ func (i *jobTemplateSpecPtrType) ToJobTemplateSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPtrOutput) } +func (i *jobTemplateSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpec] { + return pulumix.Output[*JobTemplateSpec]{ + OutputState: i.ToJobTemplateSpecPtrOutputWithContext(ctx).OutputState, + } +} + // JobTemplateSpec describes the data a Job should have when created from a template type JobTemplateSpecOutput struct{ *pulumi.OutputState } @@ -1256,6 +1413,12 @@ func (o JobTemplateSpecOutput) ToJobTemplateSpecPtrOutputWithContext(ctx context }).(JobTemplateSpecPtrOutput) } +func (o JobTemplateSpecOutput) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpec] { + return pulumix.Output[JobTemplateSpec]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o JobTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v JobTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -1280,6 +1443,12 @@ func (o JobTemplateSpecPtrOutput) ToJobTemplateSpecPtrOutputWithContext(ctx cont return o } +func (o JobTemplateSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpec] { + return pulumix.Output[*JobTemplateSpec]{ + OutputState: o.OutputState, + } +} + func (o JobTemplateSpecPtrOutput) Elem() JobTemplateSpecOutput { return o.ApplyT(func(v *JobTemplateSpec) JobTemplateSpec { if v != nil { @@ -1349,6 +1518,12 @@ func (i JobTemplateSpecPatchArgs) ToJobTemplateSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPatchOutput) } +func (i JobTemplateSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpecPatch] { + return pulumix.Output[JobTemplateSpecPatch]{ + OutputState: i.ToJobTemplateSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i JobTemplateSpecPatchArgs) ToJobTemplateSpecPatchPtrOutput() JobTemplateSpecPatchPtrOutput { return i.ToJobTemplateSpecPatchPtrOutputWithContext(context.Background()) } @@ -1390,6 +1565,12 @@ func (i *jobTemplateSpecPatchPtrType) ToJobTemplateSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPatchPtrOutput) } +func (i *jobTemplateSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpecPatch] { + return pulumix.Output[*JobTemplateSpecPatch]{ + OutputState: i.ToJobTemplateSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JobTemplateSpec describes the data a Job should have when created from a template type JobTemplateSpecPatchOutput struct{ *pulumi.OutputState } @@ -1415,6 +1596,12 @@ func (o JobTemplateSpecPatchOutput) ToJobTemplateSpecPatchPtrOutputWithContext(c }).(JobTemplateSpecPatchPtrOutput) } +func (o JobTemplateSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpecPatch] { + return pulumix.Output[JobTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o JobTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v JobTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -1439,6 +1626,12 @@ func (o JobTemplateSpecPatchPtrOutput) ToJobTemplateSpecPatchPtrOutputWithContex return o } +func (o JobTemplateSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpecPatch] { + return pulumix.Output[*JobTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o JobTemplateSpecPatchPtrOutput) Elem() JobTemplateSpecPatchOutput { return o.ApplyT(func(v *JobTemplateSpecPatch) JobTemplateSpecPatch { if v != nil { diff --git a/sdk/go/kubernetes/batch/v2alpha1/cronJob.go b/sdk/go/kubernetes/batch/v2alpha1/cronJob.go index 5abbf912c8..e44ef9d67c 100644 --- a/sdk/go/kubernetes/batch/v2alpha1/cronJob.go +++ b/sdk/go/kubernetes/batch/v2alpha1/cronJob.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CronJob represents the configuration of a single cron job. @@ -124,6 +125,12 @@ func (i *CronJob) ToCronJobOutputWithContext(ctx context.Context) CronJobOutput return pulumi.ToOutputWithContext(ctx, i).(CronJobOutput) } +func (i *CronJob) ToOutput(ctx context.Context) pulumix.Output[*CronJob] { + return pulumix.Output[*CronJob]{ + OutputState: i.ToCronJobOutputWithContext(ctx).OutputState, + } +} + // CronJobArrayInput is an input type that accepts CronJobArray and CronJobArrayOutput values. // You can construct a concrete instance of `CronJobArrayInput` via: // @@ -149,6 +156,12 @@ func (i CronJobArray) ToCronJobArrayOutputWithContext(ctx context.Context) CronJ return pulumi.ToOutputWithContext(ctx, i).(CronJobArrayOutput) } +func (i CronJobArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJob] { + return pulumix.Output[[]*CronJob]{ + OutputState: i.ToCronJobArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobMapInput is an input type that accepts CronJobMap and CronJobMapOutput values. // You can construct a concrete instance of `CronJobMapInput` via: // @@ -174,6 +187,12 @@ func (i CronJobMap) ToCronJobMapOutputWithContext(ctx context.Context) CronJobMa return pulumi.ToOutputWithContext(ctx, i).(CronJobMapOutput) } +func (i CronJobMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJob] { + return pulumix.Output[map[string]*CronJob]{ + OutputState: i.ToCronJobMapOutputWithContext(ctx).OutputState, + } +} + type CronJobOutput struct{ *pulumi.OutputState } func (CronJobOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o CronJobOutput) ToCronJobOutputWithContext(ctx context.Context) CronJobOu return o } +func (o CronJobOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJob] { + return pulumix.Output[*CronJob]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CronJob) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -227,6 +252,12 @@ func (o CronJobArrayOutput) ToCronJobArrayOutputWithContext(ctx context.Context) return o } +func (o CronJobArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJob] { + return pulumix.Output[[]*CronJob]{ + OutputState: o.OutputState, + } +} + func (o CronJobArrayOutput) Index(i pulumi.IntInput) CronJobOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJob { return vs[0].([]*CronJob)[vs[1].(int)] @@ -247,6 +278,12 @@ func (o CronJobMapOutput) ToCronJobMapOutputWithContext(ctx context.Context) Cro return o } +func (o CronJobMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJob] { + return pulumix.Output[map[string]*CronJob]{ + OutputState: o.OutputState, + } +} + func (o CronJobMapOutput) MapIndex(k pulumi.StringInput) CronJobOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJob { return vs[0].(map[string]*CronJob)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v2alpha1/cronJobList.go b/sdk/go/kubernetes/batch/v2alpha1/cronJobList.go index 7b13d16933..dd3868eb3f 100644 --- a/sdk/go/kubernetes/batch/v2alpha1/cronJobList.go +++ b/sdk/go/kubernetes/batch/v2alpha1/cronJobList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CronJobList is a collection of cron jobs. @@ -117,6 +118,12 @@ func (i *CronJobList) ToCronJobListOutputWithContext(ctx context.Context) CronJo return pulumi.ToOutputWithContext(ctx, i).(CronJobListOutput) } +func (i *CronJobList) ToOutput(ctx context.Context) pulumix.Output[*CronJobList] { + return pulumix.Output[*CronJobList]{ + OutputState: i.ToCronJobListOutputWithContext(ctx).OutputState, + } +} + // CronJobListArrayInput is an input type that accepts CronJobListArray and CronJobListArrayOutput values. // You can construct a concrete instance of `CronJobListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CronJobListArray) ToCronJobListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CronJobListArrayOutput) } +func (i CronJobListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobList] { + return pulumix.Output[[]*CronJobList]{ + OutputState: i.ToCronJobListArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobListMapInput is an input type that accepts CronJobListMap and CronJobListMapOutput values. // You can construct a concrete instance of `CronJobListMapInput` via: // @@ -167,6 +180,12 @@ func (i CronJobListMap) ToCronJobListMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CronJobListMapOutput) } +func (i CronJobListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobList] { + return pulumix.Output[map[string]*CronJobList]{ + OutputState: i.ToCronJobListMapOutputWithContext(ctx).OutputState, + } +} + type CronJobListOutput struct{ *pulumi.OutputState } func (CronJobListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CronJobListOutput) ToCronJobListOutputWithContext(ctx context.Context) C return o } +func (o CronJobListOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobList] { + return pulumix.Output[*CronJobList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CronJobList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CronJobListArrayOutput) ToCronJobListArrayOutputWithContext(ctx context. return o } +func (o CronJobListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobList] { + return pulumix.Output[[]*CronJobList]{ + OutputState: o.OutputState, + } +} + func (o CronJobListArrayOutput) Index(i pulumi.IntInput) CronJobListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJobList { return vs[0].([]*CronJobList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CronJobListMapOutput) ToCronJobListMapOutputWithContext(ctx context.Cont return o } +func (o CronJobListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobList] { + return pulumix.Output[map[string]*CronJobList]{ + OutputState: o.OutputState, + } +} + func (o CronJobListMapOutput) MapIndex(k pulumi.StringInput) CronJobListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJobList { return vs[0].(map[string]*CronJobList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v2alpha1/cronJobPatch.go b/sdk/go/kubernetes/batch/v2alpha1/cronJobPatch.go index f75ee9c0f4..e875771faa 100644 --- a/sdk/go/kubernetes/batch/v2alpha1/cronJobPatch.go +++ b/sdk/go/kubernetes/batch/v2alpha1/cronJobPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *CronJobPatch) ToCronJobPatchOutputWithContext(ctx context.Context) Cron return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchOutput) } +func (i *CronJobPatch) ToOutput(ctx context.Context) pulumix.Output[*CronJobPatch] { + return pulumix.Output[*CronJobPatch]{ + OutputState: i.ToCronJobPatchOutputWithContext(ctx).OutputState, + } +} + // CronJobPatchArrayInput is an input type that accepts CronJobPatchArray and CronJobPatchArrayOutput values. // You can construct a concrete instance of `CronJobPatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i CronJobPatchArray) ToCronJobPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchArrayOutput) } +func (i CronJobPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobPatch] { + return pulumix.Output[[]*CronJobPatch]{ + OutputState: i.ToCronJobPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CronJobPatchMapInput is an input type that accepts CronJobPatchMap and CronJobPatchMapOutput values. // You can construct a concrete instance of `CronJobPatchMapInput` via: // @@ -180,6 +193,12 @@ func (i CronJobPatchMap) ToCronJobPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchMapOutput) } +func (i CronJobPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobPatch] { + return pulumix.Output[map[string]*CronJobPatch]{ + OutputState: i.ToCronJobPatchMapOutputWithContext(ctx).OutputState, + } +} + type CronJobPatchOutput struct{ *pulumi.OutputState } func (CronJobPatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o CronJobPatchOutput) ToCronJobPatchOutputWithContext(ctx context.Context) return o } +func (o CronJobPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobPatch] { + return pulumix.Output[*CronJobPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CronJobPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -233,6 +258,12 @@ func (o CronJobPatchArrayOutput) ToCronJobPatchArrayOutputWithContext(ctx contex return o } +func (o CronJobPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CronJobPatch] { + return pulumix.Output[[]*CronJobPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobPatchArrayOutput) Index(i pulumi.IntInput) CronJobPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CronJobPatch { return vs[0].([]*CronJobPatch)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o CronJobPatchMapOutput) ToCronJobPatchMapOutputWithContext(ctx context.Co return o } +func (o CronJobPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CronJobPatch] { + return pulumix.Output[map[string]*CronJobPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobPatchMapOutput) MapIndex(k pulumi.StringInput) CronJobPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CronJobPatch { return vs[0].(map[string]*CronJobPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/batch/v2alpha1/pulumiTypes.go b/sdk/go/kubernetes/batch/v2alpha1/pulumiTypes.go index f9f9804034..099a16bf1d 100644 --- a/sdk/go/kubernetes/batch/v2alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/batch/v2alpha1/pulumiTypes.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -67,6 +68,12 @@ func (i CronJobTypeArgs) ToCronJobTypeOutputWithContext(ctx context.Context) Cro return pulumi.ToOutputWithContext(ctx, i).(CronJobTypeOutput) } +func (i CronJobTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobType] { + return pulumix.Output[CronJobType]{ + OutputState: i.ToCronJobTypeOutputWithContext(ctx).OutputState, + } +} + // CronJobTypeArrayInput is an input type that accepts CronJobTypeArray and CronJobTypeArrayOutput values. // You can construct a concrete instance of `CronJobTypeArrayInput` via: // @@ -92,6 +99,12 @@ func (i CronJobTypeArray) ToCronJobTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CronJobTypeArrayOutput) } +func (i CronJobTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CronJobType] { + return pulumix.Output[[]CronJobType]{ + OutputState: i.ToCronJobTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CronJob represents the configuration of a single cron job. type CronJobTypeOutput struct{ *pulumi.OutputState } @@ -107,6 +120,12 @@ func (o CronJobTypeOutput) ToCronJobTypeOutputWithContext(ctx context.Context) C return o } +func (o CronJobTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobType] { + return pulumix.Output[CronJobType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -146,6 +165,12 @@ func (o CronJobTypeArrayOutput) ToCronJobTypeArrayOutputWithContext(ctx context. return o } +func (o CronJobTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CronJobType] { + return pulumix.Output[[]CronJobType]{ + OutputState: o.OutputState, + } +} + func (o CronJobTypeArrayOutput) Index(i pulumi.IntInput) CronJobTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CronJobType { return vs[0].([]CronJobType)[vs[1].(int)] @@ -199,6 +224,12 @@ func (i CronJobListTypeArgs) ToCronJobListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CronJobListTypeOutput) } +func (i CronJobListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobListType] { + return pulumix.Output[CronJobListType]{ + OutputState: i.ToCronJobListTypeOutputWithContext(ctx).OutputState, + } +} + // CronJobList is a collection of cron jobs. type CronJobListTypeOutput struct{ *pulumi.OutputState } @@ -214,6 +245,12 @@ func (o CronJobListTypeOutput) ToCronJobListTypeOutputWithContext(ctx context.Co return o } +func (o CronJobListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobListType] { + return pulumix.Output[CronJobListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -285,6 +322,12 @@ func (i CronJobPatchTypeArgs) ToCronJobPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CronJobPatchTypeOutput) } +func (i CronJobPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobPatchType] { + return pulumix.Output[CronJobPatchType]{ + OutputState: i.ToCronJobPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CronJob represents the configuration of a single cron job. type CronJobPatchTypeOutput struct{ *pulumi.OutputState } @@ -300,6 +343,12 @@ func (o CronJobPatchTypeOutput) ToCronJobPatchTypeOutputWithContext(ctx context. return o } +func (o CronJobPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobPatchType] { + return pulumix.Output[CronJobPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CronJobPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -384,6 +433,12 @@ func (i CronJobSpecArgs) ToCronJobSpecOutputWithContext(ctx context.Context) Cro return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecOutput) } +func (i CronJobSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobSpec] { + return pulumix.Output[CronJobSpec]{ + OutputState: i.ToCronJobSpecOutputWithContext(ctx).OutputState, + } +} + func (i CronJobSpecArgs) ToCronJobSpecPtrOutput() CronJobSpecPtrOutput { return i.ToCronJobSpecPtrOutputWithContext(context.Background()) } @@ -425,6 +480,12 @@ func (i *cronJobSpecPtrType) ToCronJobSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPtrOutput) } +func (i *cronJobSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpec] { + return pulumix.Output[*CronJobSpec]{ + OutputState: i.ToCronJobSpecPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobSpec describes how the job execution will look like and when it will actually run. type CronJobSpecOutput struct{ *pulumi.OutputState } @@ -450,6 +511,12 @@ func (o CronJobSpecOutput) ToCronJobSpecPtrOutputWithContext(ctx context.Context }).(CronJobSpecPtrOutput) } +func (o CronJobSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobSpec] { + return pulumix.Output[CronJobSpec]{ + OutputState: o.OutputState, + } +} + // Specifies how to treat concurrent executions of a Job. Valid values are: - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one func (o CronJobSpecOutput) ConcurrencyPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobSpec) *string { return v.ConcurrencyPolicy }).(pulumi.StringPtrOutput) @@ -499,6 +566,12 @@ func (o CronJobSpecPtrOutput) ToCronJobSpecPtrOutputWithContext(ctx context.Cont return o } +func (o CronJobSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpec] { + return pulumix.Output[*CronJobSpec]{ + OutputState: o.OutputState, + } +} + func (o CronJobSpecPtrOutput) Elem() CronJobSpecOutput { return o.ApplyT(func(v *CronJobSpec) CronJobSpec { if v != nil { @@ -638,6 +711,12 @@ func (i CronJobSpecPatchArgs) ToCronJobSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPatchOutput) } +func (i CronJobSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobSpecPatch] { + return pulumix.Output[CronJobSpecPatch]{ + OutputState: i.ToCronJobSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CronJobSpecPatchArgs) ToCronJobSpecPatchPtrOutput() CronJobSpecPatchPtrOutput { return i.ToCronJobSpecPatchPtrOutputWithContext(context.Background()) } @@ -679,6 +758,12 @@ func (i *cronJobSpecPatchPtrType) ToCronJobSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(CronJobSpecPatchPtrOutput) } +func (i *cronJobSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpecPatch] { + return pulumix.Output[*CronJobSpecPatch]{ + OutputState: i.ToCronJobSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobSpec describes how the job execution will look like and when it will actually run. type CronJobSpecPatchOutput struct{ *pulumi.OutputState } @@ -704,6 +789,12 @@ func (o CronJobSpecPatchOutput) ToCronJobSpecPatchPtrOutputWithContext(ctx conte }).(CronJobSpecPatchPtrOutput) } +func (o CronJobSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobSpecPatch] { + return pulumix.Output[CronJobSpecPatch]{ + OutputState: o.OutputState, + } +} + // Specifies how to treat concurrent executions of a Job. Valid values are: - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one func (o CronJobSpecPatchOutput) ConcurrencyPolicy() pulumi.StringPtrOutput { return o.ApplyT(func(v CronJobSpecPatch) *string { return v.ConcurrencyPolicy }).(pulumi.StringPtrOutput) @@ -753,6 +844,12 @@ func (o CronJobSpecPatchPtrOutput) ToCronJobSpecPatchPtrOutputWithContext(ctx co return o } +func (o CronJobSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobSpecPatch] { + return pulumix.Output[*CronJobSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobSpecPatchPtrOutput) Elem() CronJobSpecPatchOutput { return o.ApplyT(func(v *CronJobSpecPatch) CronJobSpecPatch { if v != nil { @@ -872,6 +969,12 @@ func (i CronJobStatusArgs) ToCronJobStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusOutput) } +func (i CronJobStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobStatus] { + return pulumix.Output[CronJobStatus]{ + OutputState: i.ToCronJobStatusOutputWithContext(ctx).OutputState, + } +} + func (i CronJobStatusArgs) ToCronJobStatusPtrOutput() CronJobStatusPtrOutput { return i.ToCronJobStatusPtrOutputWithContext(context.Background()) } @@ -913,6 +1016,12 @@ func (i *cronJobStatusPtrType) ToCronJobStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPtrOutput) } +func (i *cronJobStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatus] { + return pulumix.Output[*CronJobStatus]{ + OutputState: i.ToCronJobStatusPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobStatus represents the current state of a cron job. type CronJobStatusOutput struct{ *pulumi.OutputState } @@ -938,6 +1047,12 @@ func (o CronJobStatusOutput) ToCronJobStatusPtrOutputWithContext(ctx context.Con }).(CronJobStatusPtrOutput) } +func (o CronJobStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobStatus] { + return pulumix.Output[CronJobStatus]{ + OutputState: o.OutputState, + } +} + // A list of pointers to currently running jobs. func (o CronJobStatusOutput) Active() corev1.ObjectReferenceArrayOutput { return o.ApplyT(func(v CronJobStatus) []corev1.ObjectReference { return v.Active }).(corev1.ObjectReferenceArrayOutput) @@ -962,6 +1077,12 @@ func (o CronJobStatusPtrOutput) ToCronJobStatusPtrOutputWithContext(ctx context. return o } +func (o CronJobStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatus] { + return pulumix.Output[*CronJobStatus]{ + OutputState: o.OutputState, + } +} + func (o CronJobStatusPtrOutput) Elem() CronJobStatusOutput { return o.ApplyT(func(v *CronJobStatus) CronJobStatus { if v != nil { @@ -1031,6 +1152,12 @@ func (i CronJobStatusPatchArgs) ToCronJobStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPatchOutput) } +func (i CronJobStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CronJobStatusPatch] { + return pulumix.Output[CronJobStatusPatch]{ + OutputState: i.ToCronJobStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CronJobStatusPatchArgs) ToCronJobStatusPatchPtrOutput() CronJobStatusPatchPtrOutput { return i.ToCronJobStatusPatchPtrOutputWithContext(context.Background()) } @@ -1072,6 +1199,12 @@ func (i *cronJobStatusPatchPtrType) ToCronJobStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CronJobStatusPatchPtrOutput) } +func (i *cronJobStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatusPatch] { + return pulumix.Output[*CronJobStatusPatch]{ + OutputState: i.ToCronJobStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CronJobStatus represents the current state of a cron job. type CronJobStatusPatchOutput struct{ *pulumi.OutputState } @@ -1097,6 +1230,12 @@ func (o CronJobStatusPatchOutput) ToCronJobStatusPatchPtrOutputWithContext(ctx c }).(CronJobStatusPatchPtrOutput) } +func (o CronJobStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CronJobStatusPatch] { + return pulumix.Output[CronJobStatusPatch]{ + OutputState: o.OutputState, + } +} + // A list of pointers to currently running jobs. func (o CronJobStatusPatchOutput) Active() corev1.ObjectReferencePatchArrayOutput { return o.ApplyT(func(v CronJobStatusPatch) []corev1.ObjectReferencePatch { return v.Active }).(corev1.ObjectReferencePatchArrayOutput) @@ -1121,6 +1260,12 @@ func (o CronJobStatusPatchPtrOutput) ToCronJobStatusPatchPtrOutputWithContext(ct return o } +func (o CronJobStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CronJobStatusPatch] { + return pulumix.Output[*CronJobStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CronJobStatusPatchPtrOutput) Elem() CronJobStatusPatchOutput { return o.ApplyT(func(v *CronJobStatusPatch) CronJobStatusPatch { if v != nil { @@ -1190,6 +1335,12 @@ func (i JobTemplateSpecArgs) ToJobTemplateSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecOutput) } +func (i JobTemplateSpecArgs) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpec] { + return pulumix.Output[JobTemplateSpec]{ + OutputState: i.ToJobTemplateSpecOutputWithContext(ctx).OutputState, + } +} + func (i JobTemplateSpecArgs) ToJobTemplateSpecPtrOutput() JobTemplateSpecPtrOutput { return i.ToJobTemplateSpecPtrOutputWithContext(context.Background()) } @@ -1231,6 +1382,12 @@ func (i *jobTemplateSpecPtrType) ToJobTemplateSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPtrOutput) } +func (i *jobTemplateSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpec] { + return pulumix.Output[*JobTemplateSpec]{ + OutputState: i.ToJobTemplateSpecPtrOutputWithContext(ctx).OutputState, + } +} + // JobTemplateSpec describes the data a Job should have when created from a template type JobTemplateSpecOutput struct{ *pulumi.OutputState } @@ -1256,6 +1413,12 @@ func (o JobTemplateSpecOutput) ToJobTemplateSpecPtrOutputWithContext(ctx context }).(JobTemplateSpecPtrOutput) } +func (o JobTemplateSpecOutput) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpec] { + return pulumix.Output[JobTemplateSpec]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o JobTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v JobTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -1280,6 +1443,12 @@ func (o JobTemplateSpecPtrOutput) ToJobTemplateSpecPtrOutputWithContext(ctx cont return o } +func (o JobTemplateSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpec] { + return pulumix.Output[*JobTemplateSpec]{ + OutputState: o.OutputState, + } +} + func (o JobTemplateSpecPtrOutput) Elem() JobTemplateSpecOutput { return o.ApplyT(func(v *JobTemplateSpec) JobTemplateSpec { if v != nil { @@ -1349,6 +1518,12 @@ func (i JobTemplateSpecPatchArgs) ToJobTemplateSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPatchOutput) } +func (i JobTemplateSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpecPatch] { + return pulumix.Output[JobTemplateSpecPatch]{ + OutputState: i.ToJobTemplateSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i JobTemplateSpecPatchArgs) ToJobTemplateSpecPatchPtrOutput() JobTemplateSpecPatchPtrOutput { return i.ToJobTemplateSpecPatchPtrOutputWithContext(context.Background()) } @@ -1390,6 +1565,12 @@ func (i *jobTemplateSpecPatchPtrType) ToJobTemplateSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(JobTemplateSpecPatchPtrOutput) } +func (i *jobTemplateSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpecPatch] { + return pulumix.Output[*JobTemplateSpecPatch]{ + OutputState: i.ToJobTemplateSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // JobTemplateSpec describes the data a Job should have when created from a template type JobTemplateSpecPatchOutput struct{ *pulumi.OutputState } @@ -1415,6 +1596,12 @@ func (o JobTemplateSpecPatchOutput) ToJobTemplateSpecPatchPtrOutputWithContext(c }).(JobTemplateSpecPatchPtrOutput) } +func (o JobTemplateSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[JobTemplateSpecPatch] { + return pulumix.Output[JobTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o JobTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v JobTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -1439,6 +1626,12 @@ func (o JobTemplateSpecPatchPtrOutput) ToJobTemplateSpecPatchPtrOutputWithContex return o } +func (o JobTemplateSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*JobTemplateSpecPatch] { + return pulumix.Output[*JobTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o JobTemplateSpecPatchPtrOutput) Elem() JobTemplateSpecPatchOutput { return o.ApplyT(func(v *JobTemplateSpecPatch) JobTemplateSpecPatch { if v != nil { diff --git a/sdk/go/kubernetes/certificates/v1/certificateSigningRequest.go b/sdk/go/kubernetes/certificates/v1/certificateSigningRequest.go index c44aeec06e..915c4cb379 100644 --- a/sdk/go/kubernetes/certificates/v1/certificateSigningRequest.go +++ b/sdk/go/kubernetes/certificates/v1/certificateSigningRequest.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued. @@ -128,6 +129,12 @@ func (i *CertificateSigningRequest) ToCertificateSigningRequestOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestOutput) } +func (i *CertificateSigningRequest) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequest] { + return pulumix.Output[*CertificateSigningRequest]{ + OutputState: i.ToCertificateSigningRequestOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestArrayInput is an input type that accepts CertificateSigningRequestArray and CertificateSigningRequestArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestArrayInput` via: // @@ -153,6 +160,12 @@ func (i CertificateSigningRequestArray) ToCertificateSigningRequestArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestArrayOutput) } +func (i CertificateSigningRequestArray) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequest] { + return pulumix.Output[[]*CertificateSigningRequest]{ + OutputState: i.ToCertificateSigningRequestArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestMapInput is an input type that accepts CertificateSigningRequestMap and CertificateSigningRequestMapOutput values. // You can construct a concrete instance of `CertificateSigningRequestMapInput` via: // @@ -178,6 +191,12 @@ func (i CertificateSigningRequestMap) ToCertificateSigningRequestMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestMapOutput) } +func (i CertificateSigningRequestMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequest] { + return pulumix.Output[map[string]*CertificateSigningRequest]{ + OutputState: i.ToCertificateSigningRequestMapOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o CertificateSigningRequestOutput) ToCertificateSigningRequestOutputWithCo return o } +func (o CertificateSigningRequestOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequest] { + return pulumix.Output[*CertificateSigningRequest]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CertificateSigningRequest) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o CertificateSigningRequestArrayOutput) ToCertificateSigningRequestArrayOu return o } +func (o CertificateSigningRequestArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequest] { + return pulumix.Output[[]*CertificateSigningRequest]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CertificateSigningRequest { return vs[0].([]*CertificateSigningRequest)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o CertificateSigningRequestMapOutput) ToCertificateSigningRequestMapOutput return o } +func (o CertificateSigningRequestMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequest] { + return pulumix.Output[map[string]*CertificateSigningRequest]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestMapOutput) MapIndex(k pulumi.StringInput) CertificateSigningRequestOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CertificateSigningRequest { return vs[0].(map[string]*CertificateSigningRequest)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1/certificateSigningRequestList.go b/sdk/go/kubernetes/certificates/v1/certificateSigningRequestList.go index b45adbe379..6034e23c03 100644 --- a/sdk/go/kubernetes/certificates/v1/certificateSigningRequestList.go +++ b/sdk/go/kubernetes/certificates/v1/certificateSigningRequestList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CertificateSigningRequestList is a collection of CertificateSigningRequest objects @@ -114,6 +115,12 @@ func (i *CertificateSigningRequestList) ToCertificateSigningRequestListOutputWit return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListOutput) } +func (i *CertificateSigningRequestList) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestList] { + return pulumix.Output[*CertificateSigningRequestList]{ + OutputState: i.ToCertificateSigningRequestListOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestListArrayInput is an input type that accepts CertificateSigningRequestListArray and CertificateSigningRequestListArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestListArrayInput` via: // @@ -139,6 +146,12 @@ func (i CertificateSigningRequestListArray) ToCertificateSigningRequestListArray return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListArrayOutput) } +func (i CertificateSigningRequestListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestList] { + return pulumix.Output[[]*CertificateSigningRequestList]{ + OutputState: i.ToCertificateSigningRequestListArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestListMapInput is an input type that accepts CertificateSigningRequestListMap and CertificateSigningRequestListMapOutput values. // You can construct a concrete instance of `CertificateSigningRequestListMapInput` via: // @@ -164,6 +177,12 @@ func (i CertificateSigningRequestListMap) ToCertificateSigningRequestListMapOutp return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListMapOutput) } +func (i CertificateSigningRequestListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestList] { + return pulumix.Output[map[string]*CertificateSigningRequestList]{ + OutputState: i.ToCertificateSigningRequestListMapOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestListOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestListOutput) ElementType() reflect.Type { @@ -178,6 +197,12 @@ func (o CertificateSigningRequestListOutput) ToCertificateSigningRequestListOutp return o } +func (o CertificateSigningRequestListOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestList] { + return pulumix.Output[*CertificateSigningRequestList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CertificateSigningRequestList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o CertificateSigningRequestListArrayOutput) ToCertificateSigningRequestLis return o } +func (o CertificateSigningRequestListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestList] { + return pulumix.Output[[]*CertificateSigningRequestList]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestListArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CertificateSigningRequestList { return vs[0].([]*CertificateSigningRequestList)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o CertificateSigningRequestListMapOutput) ToCertificateSigningRequestListM return o } +func (o CertificateSigningRequestListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestList] { + return pulumix.Output[map[string]*CertificateSigningRequestList]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestListMapOutput) MapIndex(k pulumi.StringInput) CertificateSigningRequestListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CertificateSigningRequestList { return vs[0].(map[string]*CertificateSigningRequestList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1/certificateSigningRequestPatch.go b/sdk/go/kubernetes/certificates/v1/certificateSigningRequestPatch.go index ce1f712c12..bd83f0288f 100644 --- a/sdk/go/kubernetes/certificates/v1/certificateSigningRequestPatch.go +++ b/sdk/go/kubernetes/certificates/v1/certificateSigningRequestPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -130,6 +131,12 @@ func (i *CertificateSigningRequestPatch) ToCertificateSigningRequestPatchOutputW return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchOutput) } +func (i *CertificateSigningRequestPatch) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestPatch] { + return pulumix.Output[*CertificateSigningRequestPatch]{ + OutputState: i.ToCertificateSigningRequestPatchOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestPatchArrayInput is an input type that accepts CertificateSigningRequestPatchArray and CertificateSigningRequestPatchArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestPatchArrayInput` via: // @@ -155,6 +162,12 @@ func (i CertificateSigningRequestPatchArray) ToCertificateSigningRequestPatchArr return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchArrayOutput) } +func (i CertificateSigningRequestPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestPatch] { + return pulumix.Output[[]*CertificateSigningRequestPatch]{ + OutputState: i.ToCertificateSigningRequestPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestPatchMapInput is an input type that accepts CertificateSigningRequestPatchMap and CertificateSigningRequestPatchMapOutput values. // You can construct a concrete instance of `CertificateSigningRequestPatchMapInput` via: // @@ -180,6 +193,12 @@ func (i CertificateSigningRequestPatchMap) ToCertificateSigningRequestPatchMapOu return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchMapOutput) } +func (i CertificateSigningRequestPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestPatch] { + return pulumix.Output[map[string]*CertificateSigningRequestPatch]{ + OutputState: i.ToCertificateSigningRequestPatchMapOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestPatchOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestPatchOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o CertificateSigningRequestPatchOutput) ToCertificateSigningRequestPatchOu return o } +func (o CertificateSigningRequestPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestPatch] { + return pulumix.Output[*CertificateSigningRequestPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CertificateSigningRequestPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -232,6 +257,12 @@ func (o CertificateSigningRequestPatchArrayOutput) ToCertificateSigningRequestPa return o } +func (o CertificateSigningRequestPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestPatch] { + return pulumix.Output[[]*CertificateSigningRequestPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestPatchArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CertificateSigningRequestPatch { return vs[0].([]*CertificateSigningRequestPatch)[vs[1].(int)] @@ -252,6 +283,12 @@ func (o CertificateSigningRequestPatchMapOutput) ToCertificateSigningRequestPatc return o } +func (o CertificateSigningRequestPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestPatch] { + return pulumix.Output[map[string]*CertificateSigningRequestPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestPatchMapOutput) MapIndex(k pulumi.StringInput) CertificateSigningRequestPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CertificateSigningRequestPatch { return vs[0].(map[string]*CertificateSigningRequestPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1/pulumiTypes.go b/sdk/go/kubernetes/certificates/v1/pulumiTypes.go index 07b74082f9..fd925d2806 100644 --- a/sdk/go/kubernetes/certificates/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/certificates/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -75,6 +76,12 @@ func (i CertificateSigningRequestTypeArgs) ToCertificateSigningRequestTypeOutput return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestTypeOutput) } +func (i CertificateSigningRequestTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestType] { + return pulumix.Output[CertificateSigningRequestType]{ + OutputState: i.ToCertificateSigningRequestTypeOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestTypeArrayInput is an input type that accepts CertificateSigningRequestTypeArray and CertificateSigningRequestTypeArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestTypeArrayInput` via: // @@ -100,6 +107,12 @@ func (i CertificateSigningRequestTypeArray) ToCertificateSigningRequestTypeArray return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestTypeArrayOutput) } +func (i CertificateSigningRequestTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestType] { + return pulumix.Output[[]CertificateSigningRequestType]{ + OutputState: i.ToCertificateSigningRequestTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued. // // Kubelets use this API to obtain: @@ -121,6 +134,12 @@ func (o CertificateSigningRequestTypeOutput) ToCertificateSigningRequestTypeOutp return o } +func (o CertificateSigningRequestTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestType] { + return pulumix.Output[CertificateSigningRequestType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -159,6 +178,12 @@ func (o CertificateSigningRequestTypeArrayOutput) ToCertificateSigningRequestTyp return o } +func (o CertificateSigningRequestTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestType] { + return pulumix.Output[[]CertificateSigningRequestType]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestTypeArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CertificateSigningRequestType { return vs[0].([]CertificateSigningRequestType)[vs[1].(int)] @@ -240,6 +265,12 @@ func (i CertificateSigningRequestConditionArgs) ToCertificateSigningRequestCondi return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionOutput) } +func (i CertificateSigningRequestConditionArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestCondition] { + return pulumix.Output[CertificateSigningRequestCondition]{ + OutputState: i.ToCertificateSigningRequestConditionOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestConditionArrayInput is an input type that accepts CertificateSigningRequestConditionArray and CertificateSigningRequestConditionArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestConditionArrayInput` via: // @@ -265,6 +296,12 @@ func (i CertificateSigningRequestConditionArray) ToCertificateSigningRequestCond return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionArrayOutput) } +func (i CertificateSigningRequestConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestCondition] { + return pulumix.Output[[]CertificateSigningRequestCondition]{ + OutputState: i.ToCertificateSigningRequestConditionArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest object type CertificateSigningRequestConditionOutput struct{ *pulumi.OutputState } @@ -280,6 +317,12 @@ func (o CertificateSigningRequestConditionOutput) ToCertificateSigningRequestCon return o } +func (o CertificateSigningRequestConditionOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestCondition] { + return pulumix.Output[CertificateSigningRequestCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the time the condition last transitioned from one status to another. If unset, when a new condition type is added or an existing condition's status is changed, the server defaults this to the current time. func (o CertificateSigningRequestConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -334,6 +377,12 @@ func (o CertificateSigningRequestConditionArrayOutput) ToCertificateSigningReque return o } +func (o CertificateSigningRequestConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestCondition] { + return pulumix.Output[[]CertificateSigningRequestCondition]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestConditionArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CertificateSigningRequestCondition { return vs[0].([]CertificateSigningRequestCondition)[vs[1].(int)] @@ -415,6 +464,12 @@ func (i CertificateSigningRequestConditionPatchArgs) ToCertificateSigningRequest return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionPatchOutput) } +func (i CertificateSigningRequestConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestConditionPatch] { + return pulumix.Output[CertificateSigningRequestConditionPatch]{ + OutputState: i.ToCertificateSigningRequestConditionPatchOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestConditionPatchArrayInput is an input type that accepts CertificateSigningRequestConditionPatchArray and CertificateSigningRequestConditionPatchArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestConditionPatchArrayInput` via: // @@ -440,6 +495,12 @@ func (i CertificateSigningRequestConditionPatchArray) ToCertificateSigningReques return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionPatchArrayOutput) } +func (i CertificateSigningRequestConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestConditionPatch] { + return pulumix.Output[[]CertificateSigningRequestConditionPatch]{ + OutputState: i.ToCertificateSigningRequestConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest object type CertificateSigningRequestConditionPatchOutput struct{ *pulumi.OutputState } @@ -455,6 +516,12 @@ func (o CertificateSigningRequestConditionPatchOutput) ToCertificateSigningReque return o } +func (o CertificateSigningRequestConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestConditionPatch] { + return pulumix.Output[CertificateSigningRequestConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the time the condition last transitioned from one status to another. If unset, when a new condition type is added or an existing condition's status is changed, the server defaults this to the current time. func (o CertificateSigningRequestConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -509,6 +576,12 @@ func (o CertificateSigningRequestConditionPatchArrayOutput) ToCertificateSigning return o } +func (o CertificateSigningRequestConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestConditionPatch] { + return pulumix.Output[[]CertificateSigningRequestConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestConditionPatchArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CertificateSigningRequestConditionPatch { return vs[0].([]CertificateSigningRequestConditionPatch)[vs[1].(int)] @@ -560,6 +633,12 @@ func (i CertificateSigningRequestListTypeArgs) ToCertificateSigningRequestListTy return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListTypeOutput) } +func (i CertificateSigningRequestListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestListType] { + return pulumix.Output[CertificateSigningRequestListType]{ + OutputState: i.ToCertificateSigningRequestListTypeOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestList is a collection of CertificateSigningRequest objects type CertificateSigningRequestListTypeOutput struct{ *pulumi.OutputState } @@ -575,6 +654,12 @@ func (o CertificateSigningRequestListTypeOutput) ToCertificateSigningRequestList return o } +func (o CertificateSigningRequestListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestListType] { + return pulumix.Output[CertificateSigningRequestListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -655,6 +740,12 @@ func (i CertificateSigningRequestPatchTypeArgs) ToCertificateSigningRequestPatch return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchTypeOutput) } +func (i CertificateSigningRequestPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestPatchType] { + return pulumix.Output[CertificateSigningRequestPatchType]{ + OutputState: i.ToCertificateSigningRequestPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued. // // Kubelets use this API to obtain: @@ -676,6 +767,12 @@ func (o CertificateSigningRequestPatchTypeOutput) ToCertificateSigningRequestPat return o } +func (o CertificateSigningRequestPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestPatchType] { + return pulumix.Output[CertificateSigningRequestPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -851,6 +948,12 @@ func (i CertificateSigningRequestSpecArgs) ToCertificateSigningRequestSpecOutput return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecOutput) } +func (i CertificateSigningRequestSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpec] { + return pulumix.Output[CertificateSigningRequestSpec]{ + OutputState: i.ToCertificateSigningRequestSpecOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestSpec contains the certificate request. type CertificateSigningRequestSpecOutput struct{ *pulumi.OutputState } @@ -866,6 +969,12 @@ func (o CertificateSigningRequestSpecOutput) ToCertificateSigningRequestSpecOutp return o } +func (o CertificateSigningRequestSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpec] { + return pulumix.Output[CertificateSigningRequestSpec]{ + OutputState: o.OutputState, + } +} + // expirationSeconds is the requested duration of validity of the issued certificate. The certificate signer may issue a certificate with a different validity duration so a client must check the delta between the notBefore and and notAfter fields in the issued certificate to determine the actual duration. // // The v1.22+ in-tree implementations of the well-known Kubernetes signers will honor this field as long as the requested duration is not greater than the maximum duration they will honor per the --cluster-signing-duration CLI flag to the Kubernetes controller manager. @@ -1102,6 +1211,12 @@ func (i CertificateSigningRequestSpecPatchArgs) ToCertificateSigningRequestSpecP return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecPatchOutput) } +func (i CertificateSigningRequestSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpecPatch] { + return pulumix.Output[CertificateSigningRequestSpecPatch]{ + OutputState: i.ToCertificateSigningRequestSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestSpecPatchArgs) ToCertificateSigningRequestSpecPatchPtrOutput() CertificateSigningRequestSpecPatchPtrOutput { return i.ToCertificateSigningRequestSpecPatchPtrOutputWithContext(context.Background()) } @@ -1143,6 +1258,12 @@ func (i *certificateSigningRequestSpecPatchPtrType) ToCertificateSigningRequestS return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecPatchPtrOutput) } +func (i *certificateSigningRequestSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestSpecPatch] { + return pulumix.Output[*CertificateSigningRequestSpecPatch]{ + OutputState: i.ToCertificateSigningRequestSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestSpec contains the certificate request. type CertificateSigningRequestSpecPatchOutput struct{ *pulumi.OutputState } @@ -1168,6 +1289,12 @@ func (o CertificateSigningRequestSpecPatchOutput) ToCertificateSigningRequestSpe }).(CertificateSigningRequestSpecPatchPtrOutput) } +func (o CertificateSigningRequestSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpecPatch] { + return pulumix.Output[CertificateSigningRequestSpecPatch]{ + OutputState: o.OutputState, + } +} + // expirationSeconds is the requested duration of validity of the issued certificate. The certificate signer may issue a certificate with a different validity duration so a client must check the delta between the notBefore and and notAfter fields in the issued certificate to determine the actual duration. // // The v1.22+ in-tree implementations of the well-known Kubernetes signers will honor this field as long as the requested duration is not greater than the maximum duration they will honor per the --cluster-signing-duration CLI flag to the Kubernetes controller manager. @@ -1267,6 +1394,12 @@ func (o CertificateSigningRequestSpecPatchPtrOutput) ToCertificateSigningRequest return o } +func (o CertificateSigningRequestSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestSpecPatch] { + return pulumix.Output[*CertificateSigningRequestSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestSpecPatchPtrOutput) Elem() CertificateSigningRequestSpecPatchOutput { return o.ApplyT(func(v *CertificateSigningRequestSpecPatch) CertificateSigningRequestSpecPatch { if v != nil { @@ -1483,6 +1616,12 @@ func (i CertificateSigningRequestStatusArgs) ToCertificateSigningRequestStatusOu return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusOutput) } +func (i CertificateSigningRequestStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatus] { + return pulumix.Output[CertificateSigningRequestStatus]{ + OutputState: i.ToCertificateSigningRequestStatusOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestStatusArgs) ToCertificateSigningRequestStatusPtrOutput() CertificateSigningRequestStatusPtrOutput { return i.ToCertificateSigningRequestStatusPtrOutputWithContext(context.Background()) } @@ -1524,6 +1663,12 @@ func (i *certificateSigningRequestStatusPtrType) ToCertificateSigningRequestStat return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusPtrOutput) } +func (i *certificateSigningRequestStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatus] { + return pulumix.Output[*CertificateSigningRequestStatus]{ + OutputState: i.ToCertificateSigningRequestStatusPtrOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate. type CertificateSigningRequestStatusOutput struct{ *pulumi.OutputState } @@ -1549,6 +1694,12 @@ func (o CertificateSigningRequestStatusOutput) ToCertificateSigningRequestStatus }).(CertificateSigningRequestStatusPtrOutput) } +func (o CertificateSigningRequestStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatus] { + return pulumix.Output[CertificateSigningRequestStatus]{ + OutputState: o.OutputState, + } +} + // certificate is populated with an issued certificate by the signer after an Approved condition is present. This field is set via the /status subresource. Once populated, this field is immutable. // // If the certificate signing request is denied, a condition of type "Denied" is added and this field remains empty. If the signer cannot issue the certificate, a condition of type "Failed" is added and this field remains empty. @@ -1594,6 +1745,12 @@ func (o CertificateSigningRequestStatusPtrOutput) ToCertificateSigningRequestSta return o } +func (o CertificateSigningRequestStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatus] { + return pulumix.Output[*CertificateSigningRequestStatus]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestStatusPtrOutput) Elem() CertificateSigningRequestStatusOutput { return o.ApplyT(func(v *CertificateSigningRequestStatus) CertificateSigningRequestStatus { if v != nil { @@ -1726,6 +1883,12 @@ func (i CertificateSigningRequestStatusPatchArgs) ToCertificateSigningRequestSta return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusPatchOutput) } +func (i CertificateSigningRequestStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatusPatch] { + return pulumix.Output[CertificateSigningRequestStatusPatch]{ + OutputState: i.ToCertificateSigningRequestStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestStatusPatchArgs) ToCertificateSigningRequestStatusPatchPtrOutput() CertificateSigningRequestStatusPatchPtrOutput { return i.ToCertificateSigningRequestStatusPatchPtrOutputWithContext(context.Background()) } @@ -1767,6 +1930,12 @@ func (i *certificateSigningRequestStatusPatchPtrType) ToCertificateSigningReques return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusPatchPtrOutput) } +func (i *certificateSigningRequestStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatusPatch] { + return pulumix.Output[*CertificateSigningRequestStatusPatch]{ + OutputState: i.ToCertificateSigningRequestStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate. type CertificateSigningRequestStatusPatchOutput struct{ *pulumi.OutputState } @@ -1792,6 +1961,12 @@ func (o CertificateSigningRequestStatusPatchOutput) ToCertificateSigningRequestS }).(CertificateSigningRequestStatusPatchPtrOutput) } +func (o CertificateSigningRequestStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatusPatch] { + return pulumix.Output[CertificateSigningRequestStatusPatch]{ + OutputState: o.OutputState, + } +} + // certificate is populated with an issued certificate by the signer after an Approved condition is present. This field is set via the /status subresource. Once populated, this field is immutable. // // If the certificate signing request is denied, a condition of type "Denied" is added and this field remains empty. If the signer cannot issue the certificate, a condition of type "Failed" is added and this field remains empty. @@ -1839,6 +2014,12 @@ func (o CertificateSigningRequestStatusPatchPtrOutput) ToCertificateSigningReque return o } +func (o CertificateSigningRequestStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatusPatch] { + return pulumix.Output[*CertificateSigningRequestStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestStatusPatchPtrOutput) Elem() CertificateSigningRequestStatusPatchOutput { return o.ApplyT(func(v *CertificateSigningRequestStatusPatch) CertificateSigningRequestStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundle.go b/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundle.go index f30f7df074..5e129d2165 100644 --- a/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundle.go +++ b/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundle.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterTrustBundle is a cluster-scoped container for X.509 trust anchors (root certificates). @@ -121,6 +122,12 @@ func (i *ClusterTrustBundle) ToClusterTrustBundleOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleOutput) } +func (i *ClusterTrustBundle) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundle] { + return pulumix.Output[*ClusterTrustBundle]{ + OutputState: i.ToClusterTrustBundleOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleArrayInput is an input type that accepts ClusterTrustBundleArray and ClusterTrustBundleArrayOutput values. // You can construct a concrete instance of `ClusterTrustBundleArrayInput` via: // @@ -146,6 +153,12 @@ func (i ClusterTrustBundleArray) ToClusterTrustBundleArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleArrayOutput) } +func (i ClusterTrustBundleArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterTrustBundle] { + return pulumix.Output[[]*ClusterTrustBundle]{ + OutputState: i.ToClusterTrustBundleArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleMapInput is an input type that accepts ClusterTrustBundleMap and ClusterTrustBundleMapOutput values. // You can construct a concrete instance of `ClusterTrustBundleMapInput` via: // @@ -171,6 +184,12 @@ func (i ClusterTrustBundleMap) ToClusterTrustBundleMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleMapOutput) } +func (i ClusterTrustBundleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterTrustBundle] { + return pulumix.Output[map[string]*ClusterTrustBundle]{ + OutputState: i.ToClusterTrustBundleMapOutputWithContext(ctx).OutputState, + } +} + type ClusterTrustBundleOutput struct{ *pulumi.OutputState } func (ClusterTrustBundleOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o ClusterTrustBundleOutput) ToClusterTrustBundleOutputWithContext(ctx cont return o } +func (o ClusterTrustBundleOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundle] { + return pulumix.Output[*ClusterTrustBundle]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterTrustBundleOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterTrustBundle) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -219,6 +244,12 @@ func (o ClusterTrustBundleArrayOutput) ToClusterTrustBundleArrayOutputWithContex return o } +func (o ClusterTrustBundleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterTrustBundle] { + return pulumix.Output[[]*ClusterTrustBundle]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundleArrayOutput) Index(i pulumi.IntInput) ClusterTrustBundleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterTrustBundle { return vs[0].([]*ClusterTrustBundle)[vs[1].(int)] @@ -239,6 +270,12 @@ func (o ClusterTrustBundleMapOutput) ToClusterTrustBundleMapOutputWithContext(ct return o } +func (o ClusterTrustBundleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterTrustBundle] { + return pulumix.Output[map[string]*ClusterTrustBundle]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundleMapOutput) MapIndex(k pulumi.StringInput) ClusterTrustBundleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterTrustBundle { return vs[0].(map[string]*ClusterTrustBundle)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundleList.go b/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundleList.go index 645e338a9f..4e6bb63e0f 100644 --- a/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundleList.go +++ b/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterTrustBundleList is a collection of ClusterTrustBundle objects @@ -117,6 +118,12 @@ func (i *ClusterTrustBundleList) ToClusterTrustBundleListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleListOutput) } +func (i *ClusterTrustBundleList) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundleList] { + return pulumix.Output[*ClusterTrustBundleList]{ + OutputState: i.ToClusterTrustBundleListOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleListArrayInput is an input type that accepts ClusterTrustBundleListArray and ClusterTrustBundleListArrayOutput values. // You can construct a concrete instance of `ClusterTrustBundleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterTrustBundleListArray) ToClusterTrustBundleListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleListArrayOutput) } +func (i ClusterTrustBundleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterTrustBundleList] { + return pulumix.Output[[]*ClusterTrustBundleList]{ + OutputState: i.ToClusterTrustBundleListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleListMapInput is an input type that accepts ClusterTrustBundleListMap and ClusterTrustBundleListMapOutput values. // You can construct a concrete instance of `ClusterTrustBundleListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterTrustBundleListMap) ToClusterTrustBundleListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleListMapOutput) } +func (i ClusterTrustBundleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterTrustBundleList] { + return pulumix.Output[map[string]*ClusterTrustBundleList]{ + OutputState: i.ToClusterTrustBundleListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterTrustBundleListOutput struct{ *pulumi.OutputState } func (ClusterTrustBundleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterTrustBundleListOutput) ToClusterTrustBundleListOutputWithContext( return o } +func (o ClusterTrustBundleListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundleList] { + return pulumix.Output[*ClusterTrustBundleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterTrustBundleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterTrustBundleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterTrustBundleListArrayOutput) ToClusterTrustBundleListArrayOutputWi return o } +func (o ClusterTrustBundleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterTrustBundleList] { + return pulumix.Output[[]*ClusterTrustBundleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundleListArrayOutput) Index(i pulumi.IntInput) ClusterTrustBundleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterTrustBundleList { return vs[0].([]*ClusterTrustBundleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterTrustBundleListMapOutput) ToClusterTrustBundleListMapOutputWithCo return o } +func (o ClusterTrustBundleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterTrustBundleList] { + return pulumix.Output[map[string]*ClusterTrustBundleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundleListMapOutput) MapIndex(k pulumi.StringInput) ClusterTrustBundleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterTrustBundleList { return vs[0].(map[string]*ClusterTrustBundleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundlePatch.go b/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundlePatch.go index 5599daaaa0..ea01f62f3e 100644 --- a/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundlePatch.go +++ b/sdk/go/kubernetes/certificates/v1alpha1/clusterTrustBundlePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -123,6 +124,12 @@ func (i *ClusterTrustBundlePatch) ToClusterTrustBundlePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundlePatchOutput) } +func (i *ClusterTrustBundlePatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundlePatch] { + return pulumix.Output[*ClusterTrustBundlePatch]{ + OutputState: i.ToClusterTrustBundlePatchOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundlePatchArrayInput is an input type that accepts ClusterTrustBundlePatchArray and ClusterTrustBundlePatchArrayOutput values. // You can construct a concrete instance of `ClusterTrustBundlePatchArrayInput` via: // @@ -148,6 +155,12 @@ func (i ClusterTrustBundlePatchArray) ToClusterTrustBundlePatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundlePatchArrayOutput) } +func (i ClusterTrustBundlePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterTrustBundlePatch] { + return pulumix.Output[[]*ClusterTrustBundlePatch]{ + OutputState: i.ToClusterTrustBundlePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundlePatchMapInput is an input type that accepts ClusterTrustBundlePatchMap and ClusterTrustBundlePatchMapOutput values. // You can construct a concrete instance of `ClusterTrustBundlePatchMapInput` via: // @@ -173,6 +186,12 @@ func (i ClusterTrustBundlePatchMap) ToClusterTrustBundlePatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundlePatchMapOutput) } +func (i ClusterTrustBundlePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterTrustBundlePatch] { + return pulumix.Output[map[string]*ClusterTrustBundlePatch]{ + OutputState: i.ToClusterTrustBundlePatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterTrustBundlePatchOutput struct{ *pulumi.OutputState } func (ClusterTrustBundlePatchOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o ClusterTrustBundlePatchOutput) ToClusterTrustBundlePatchOutputWithContex return o } +func (o ClusterTrustBundlePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundlePatch] { + return pulumix.Output[*ClusterTrustBundlePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterTrustBundlePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ClusterTrustBundlePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -221,6 +246,12 @@ func (o ClusterTrustBundlePatchArrayOutput) ToClusterTrustBundlePatchArrayOutput return o } +func (o ClusterTrustBundlePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterTrustBundlePatch] { + return pulumix.Output[[]*ClusterTrustBundlePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundlePatchArrayOutput) Index(i pulumi.IntInput) ClusterTrustBundlePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterTrustBundlePatch { return vs[0].([]*ClusterTrustBundlePatch)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o ClusterTrustBundlePatchMapOutput) ToClusterTrustBundlePatchMapOutputWith return o } +func (o ClusterTrustBundlePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterTrustBundlePatch] { + return pulumix.Output[map[string]*ClusterTrustBundlePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundlePatchMapOutput) MapIndex(k pulumi.StringInput) ClusterTrustBundlePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterTrustBundlePatch { return vs[0].(map[string]*ClusterTrustBundlePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/certificates/v1alpha1/pulumiTypes.go index 29e1926bae..8d4ed83f60 100644 --- a/sdk/go/kubernetes/certificates/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/certificates/v1alpha1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -69,6 +70,12 @@ func (i ClusterTrustBundleTypeArgs) ToClusterTrustBundleTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleTypeOutput) } +func (i ClusterTrustBundleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleType] { + return pulumix.Output[ClusterTrustBundleType]{ + OutputState: i.ToClusterTrustBundleTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleTypeArrayInput is an input type that accepts ClusterTrustBundleTypeArray and ClusterTrustBundleTypeArrayOutput values. // You can construct a concrete instance of `ClusterTrustBundleTypeArrayInput` via: // @@ -94,6 +101,12 @@ func (i ClusterTrustBundleTypeArray) ToClusterTrustBundleTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleTypeArrayOutput) } +func (i ClusterTrustBundleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterTrustBundleType] { + return pulumix.Output[[]ClusterTrustBundleType]{ + OutputState: i.ToClusterTrustBundleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundle is a cluster-scoped container for X.509 trust anchors (root certificates). // // ClusterTrustBundle objects are considered to be readable by any authenticated user in the cluster, because they can be mounted by pods using the `clusterTrustBundle` projection. All service accounts have read access to ClusterTrustBundles by default. Users who only have namespace-level access to a cluster can read ClusterTrustBundles by impersonating a serviceaccount that they have access to. @@ -113,6 +126,12 @@ func (o ClusterTrustBundleTypeOutput) ToClusterTrustBundleTypeOutputWithContext( return o } +func (o ClusterTrustBundleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleType] { + return pulumix.Output[ClusterTrustBundleType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterTrustBundleTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterTrustBundleType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -147,6 +166,12 @@ func (o ClusterTrustBundleTypeArrayOutput) ToClusterTrustBundleTypeArrayOutputWi return o } +func (o ClusterTrustBundleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterTrustBundleType] { + return pulumix.Output[[]ClusterTrustBundleType]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundleTypeArrayOutput) Index(i pulumi.IntInput) ClusterTrustBundleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterTrustBundleType { return vs[0].([]ClusterTrustBundleType)[vs[1].(int)] @@ -200,6 +225,12 @@ func (i ClusterTrustBundleListTypeArgs) ToClusterTrustBundleListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleListTypeOutput) } +func (i ClusterTrustBundleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleListType] { + return pulumix.Output[ClusterTrustBundleListType]{ + OutputState: i.ToClusterTrustBundleListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleList is a collection of ClusterTrustBundle objects type ClusterTrustBundleListTypeOutput struct{ *pulumi.OutputState } @@ -215,6 +246,12 @@ func (o ClusterTrustBundleListTypeOutput) ToClusterTrustBundleListTypeOutputWith return o } +func (o ClusterTrustBundleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleListType] { + return pulumix.Output[ClusterTrustBundleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterTrustBundleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterTrustBundleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -290,6 +327,12 @@ func (i ClusterTrustBundlePatchTypeArgs) ToClusterTrustBundlePatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundlePatchTypeOutput) } +func (i ClusterTrustBundlePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundlePatchType] { + return pulumix.Output[ClusterTrustBundlePatchType]{ + OutputState: i.ToClusterTrustBundlePatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundle is a cluster-scoped container for X.509 trust anchors (root certificates). // // ClusterTrustBundle objects are considered to be readable by any authenticated user in the cluster, because they can be mounted by pods using the `clusterTrustBundle` projection. All service accounts have read access to ClusterTrustBundles by default. Users who only have namespace-level access to a cluster can read ClusterTrustBundles by impersonating a serviceaccount that they have access to. @@ -309,6 +352,12 @@ func (o ClusterTrustBundlePatchTypeOutput) ToClusterTrustBundlePatchTypeOutputWi return o } +func (o ClusterTrustBundlePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundlePatchType] { + return pulumix.Output[ClusterTrustBundlePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterTrustBundlePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterTrustBundlePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -392,6 +441,12 @@ func (i ClusterTrustBundleSpecArgs) ToClusterTrustBundleSpecOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleSpecOutput) } +func (i ClusterTrustBundleSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleSpec] { + return pulumix.Output[ClusterTrustBundleSpec]{ + OutputState: i.ToClusterTrustBundleSpecOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleSpec contains the signer and trust anchors. type ClusterTrustBundleSpecOutput struct{ *pulumi.OutputState } @@ -407,6 +462,12 @@ func (o ClusterTrustBundleSpecOutput) ToClusterTrustBundleSpecOutputWithContext( return o } +func (o ClusterTrustBundleSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleSpec] { + return pulumix.Output[ClusterTrustBundleSpec]{ + OutputState: o.OutputState, + } +} + // signerName indicates the associated signer, if any. // // In order to create or update a ClusterTrustBundle that sets signerName, you must have the following cluster-scoped permission: group=certificates.k8s.io resource=signers resourceName= verb=attest. @@ -492,6 +553,12 @@ func (i ClusterTrustBundleSpecPatchArgs) ToClusterTrustBundleSpecPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleSpecPatchOutput) } +func (i ClusterTrustBundleSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleSpecPatch] { + return pulumix.Output[ClusterTrustBundleSpecPatch]{ + OutputState: i.ToClusterTrustBundleSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ClusterTrustBundleSpecPatchArgs) ToClusterTrustBundleSpecPatchPtrOutput() ClusterTrustBundleSpecPatchPtrOutput { return i.ToClusterTrustBundleSpecPatchPtrOutputWithContext(context.Background()) } @@ -533,6 +600,12 @@ func (i *clusterTrustBundleSpecPatchPtrType) ToClusterTrustBundleSpecPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(ClusterTrustBundleSpecPatchPtrOutput) } +func (i *clusterTrustBundleSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundleSpecPatch] { + return pulumix.Output[*ClusterTrustBundleSpecPatch]{ + OutputState: i.ToClusterTrustBundleSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ClusterTrustBundleSpec contains the signer and trust anchors. type ClusterTrustBundleSpecPatchOutput struct{ *pulumi.OutputState } @@ -558,6 +631,12 @@ func (o ClusterTrustBundleSpecPatchOutput) ToClusterTrustBundleSpecPatchPtrOutpu }).(ClusterTrustBundleSpecPatchPtrOutput) } +func (o ClusterTrustBundleSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterTrustBundleSpecPatch] { + return pulumix.Output[ClusterTrustBundleSpecPatch]{ + OutputState: o.OutputState, + } +} + // signerName indicates the associated signer, if any. // // In order to create or update a ClusterTrustBundle that sets signerName, you must have the following cluster-scoped permission: group=certificates.k8s.io resource=signers resourceName= verb=attest. @@ -594,6 +673,12 @@ func (o ClusterTrustBundleSpecPatchPtrOutput) ToClusterTrustBundleSpecPatchPtrOu return o } +func (o ClusterTrustBundleSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterTrustBundleSpecPatch] { + return pulumix.Output[*ClusterTrustBundleSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterTrustBundleSpecPatchPtrOutput) Elem() ClusterTrustBundleSpecPatchOutput { return o.ApplyT(func(v *ClusterTrustBundleSpecPatch) ClusterTrustBundleSpecPatch { if v != nil { diff --git a/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequest.go b/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequest.go index aa9827e726..01b582487f 100644 --- a/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequest.go +++ b/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequest.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Describes a certificate signing request @@ -118,6 +119,12 @@ func (i *CertificateSigningRequest) ToCertificateSigningRequestOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestOutput) } +func (i *CertificateSigningRequest) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequest] { + return pulumix.Output[*CertificateSigningRequest]{ + OutputState: i.ToCertificateSigningRequestOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestArrayInput is an input type that accepts CertificateSigningRequestArray and CertificateSigningRequestArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestArrayInput` via: // @@ -143,6 +150,12 @@ func (i CertificateSigningRequestArray) ToCertificateSigningRequestArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestArrayOutput) } +func (i CertificateSigningRequestArray) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequest] { + return pulumix.Output[[]*CertificateSigningRequest]{ + OutputState: i.ToCertificateSigningRequestArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestMapInput is an input type that accepts CertificateSigningRequestMap and CertificateSigningRequestMapOutput values. // You can construct a concrete instance of `CertificateSigningRequestMapInput` via: // @@ -168,6 +181,12 @@ func (i CertificateSigningRequestMap) ToCertificateSigningRequestMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestMapOutput) } +func (i CertificateSigningRequestMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequest] { + return pulumix.Output[map[string]*CertificateSigningRequest]{ + OutputState: i.ToCertificateSigningRequestMapOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestOutput) ElementType() reflect.Type { @@ -182,6 +201,12 @@ func (o CertificateSigningRequestOutput) ToCertificateSigningRequestOutputWithCo return o } +func (o CertificateSigningRequestOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequest] { + return pulumix.Output[*CertificateSigningRequest]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CertificateSigningRequest) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -220,6 +245,12 @@ func (o CertificateSigningRequestArrayOutput) ToCertificateSigningRequestArrayOu return o } +func (o CertificateSigningRequestArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequest] { + return pulumix.Output[[]*CertificateSigningRequest]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CertificateSigningRequest { return vs[0].([]*CertificateSigningRequest)[vs[1].(int)] @@ -240,6 +271,12 @@ func (o CertificateSigningRequestMapOutput) ToCertificateSigningRequestMapOutput return o } +func (o CertificateSigningRequestMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequest] { + return pulumix.Output[map[string]*CertificateSigningRequest]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestMapOutput) MapIndex(k pulumi.StringInput) CertificateSigningRequestOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CertificateSigningRequest { return vs[0].(map[string]*CertificateSigningRequest)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestList.go b/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestList.go index 75f8c5653c..239b712ab1 100644 --- a/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestList.go +++ b/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) type CertificateSigningRequestList struct { @@ -110,6 +111,12 @@ func (i *CertificateSigningRequestList) ToCertificateSigningRequestListOutputWit return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListOutput) } +func (i *CertificateSigningRequestList) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestList] { + return pulumix.Output[*CertificateSigningRequestList]{ + OutputState: i.ToCertificateSigningRequestListOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestListArrayInput is an input type that accepts CertificateSigningRequestListArray and CertificateSigningRequestListArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestListArrayInput` via: // @@ -135,6 +142,12 @@ func (i CertificateSigningRequestListArray) ToCertificateSigningRequestListArray return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListArrayOutput) } +func (i CertificateSigningRequestListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestList] { + return pulumix.Output[[]*CertificateSigningRequestList]{ + OutputState: i.ToCertificateSigningRequestListArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestListMapInput is an input type that accepts CertificateSigningRequestListMap and CertificateSigningRequestListMapOutput values. // You can construct a concrete instance of `CertificateSigningRequestListMapInput` via: // @@ -160,6 +173,12 @@ func (i CertificateSigningRequestListMap) ToCertificateSigningRequestListMapOutp return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListMapOutput) } +func (i CertificateSigningRequestListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestList] { + return pulumix.Output[map[string]*CertificateSigningRequestList]{ + OutputState: i.ToCertificateSigningRequestListMapOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestListOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestListOutput) ElementType() reflect.Type { @@ -174,6 +193,12 @@ func (o CertificateSigningRequestListOutput) ToCertificateSigningRequestListOutp return o } +func (o CertificateSigningRequestListOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestList] { + return pulumix.Output[*CertificateSigningRequestList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CertificateSigningRequestList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -206,6 +231,12 @@ func (o CertificateSigningRequestListArrayOutput) ToCertificateSigningRequestLis return o } +func (o CertificateSigningRequestListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestList] { + return pulumix.Output[[]*CertificateSigningRequestList]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestListArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CertificateSigningRequestList { return vs[0].([]*CertificateSigningRequestList)[vs[1].(int)] @@ -226,6 +257,12 @@ func (o CertificateSigningRequestListMapOutput) ToCertificateSigningRequestListM return o } +func (o CertificateSigningRequestListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestList] { + return pulumix.Output[map[string]*CertificateSigningRequestList]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestListMapOutput) MapIndex(k pulumi.StringInput) CertificateSigningRequestListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CertificateSigningRequestList { return vs[0].(map[string]*CertificateSigningRequestList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestPatch.go b/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestPatch.go index 73f369988c..dd64a2e868 100644 --- a/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestPatch.go +++ b/sdk/go/kubernetes/certificates/v1beta1/certificateSigningRequestPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -124,6 +125,12 @@ func (i *CertificateSigningRequestPatch) ToCertificateSigningRequestPatchOutputW return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchOutput) } +func (i *CertificateSigningRequestPatch) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestPatch] { + return pulumix.Output[*CertificateSigningRequestPatch]{ + OutputState: i.ToCertificateSigningRequestPatchOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestPatchArrayInput is an input type that accepts CertificateSigningRequestPatchArray and CertificateSigningRequestPatchArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestPatchArrayInput` via: // @@ -149,6 +156,12 @@ func (i CertificateSigningRequestPatchArray) ToCertificateSigningRequestPatchArr return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchArrayOutput) } +func (i CertificateSigningRequestPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestPatch] { + return pulumix.Output[[]*CertificateSigningRequestPatch]{ + OutputState: i.ToCertificateSigningRequestPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestPatchMapInput is an input type that accepts CertificateSigningRequestPatchMap and CertificateSigningRequestPatchMapOutput values. // You can construct a concrete instance of `CertificateSigningRequestPatchMapInput` via: // @@ -174,6 +187,12 @@ func (i CertificateSigningRequestPatchMap) ToCertificateSigningRequestPatchMapOu return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchMapOutput) } +func (i CertificateSigningRequestPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestPatch] { + return pulumix.Output[map[string]*CertificateSigningRequestPatch]{ + OutputState: i.ToCertificateSigningRequestPatchMapOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestPatchOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestPatchOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o CertificateSigningRequestPatchOutput) ToCertificateSigningRequestPatchOu return o } +func (o CertificateSigningRequestPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestPatch] { + return pulumix.Output[*CertificateSigningRequestPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CertificateSigningRequestPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o CertificateSigningRequestPatchArrayOutput) ToCertificateSigningRequestPa return o } +func (o CertificateSigningRequestPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CertificateSigningRequestPatch] { + return pulumix.Output[[]*CertificateSigningRequestPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestPatchArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CertificateSigningRequestPatch { return vs[0].([]*CertificateSigningRequestPatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o CertificateSigningRequestPatchMapOutput) ToCertificateSigningRequestPatc return o } +func (o CertificateSigningRequestPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CertificateSigningRequestPatch] { + return pulumix.Output[map[string]*CertificateSigningRequestPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestPatchMapOutput) MapIndex(k pulumi.StringInput) CertificateSigningRequestPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CertificateSigningRequestPatch { return vs[0].(map[string]*CertificateSigningRequestPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/certificates/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/certificates/v1beta1/pulumiTypes.go index 906dde8a0b..71a78cd213 100644 --- a/sdk/go/kubernetes/certificates/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/certificates/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -63,6 +64,12 @@ func (i CertificateSigningRequestTypeArgs) ToCertificateSigningRequestTypeOutput return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestTypeOutput) } +func (i CertificateSigningRequestTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestType] { + return pulumix.Output[CertificateSigningRequestType]{ + OutputState: i.ToCertificateSigningRequestTypeOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestTypeArrayInput is an input type that accepts CertificateSigningRequestTypeArray and CertificateSigningRequestTypeArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestTypeArrayInput` via: // @@ -88,6 +95,12 @@ func (i CertificateSigningRequestTypeArray) ToCertificateSigningRequestTypeArray return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestTypeArrayOutput) } +func (i CertificateSigningRequestTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestType] { + return pulumix.Output[[]CertificateSigningRequestType]{ + OutputState: i.ToCertificateSigningRequestTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Describes a certificate signing request type CertificateSigningRequestTypeOutput struct{ *pulumi.OutputState } @@ -103,6 +116,12 @@ func (o CertificateSigningRequestTypeOutput) ToCertificateSigningRequestTypeOutp return o } +func (o CertificateSigningRequestTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestType] { + return pulumix.Output[CertificateSigningRequestType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -141,6 +160,12 @@ func (o CertificateSigningRequestTypeArrayOutput) ToCertificateSigningRequestTyp return o } +func (o CertificateSigningRequestTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestType] { + return pulumix.Output[[]CertificateSigningRequestType]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestTypeArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CertificateSigningRequestType { return vs[0].([]CertificateSigningRequestType)[vs[1].(int)] @@ -200,6 +225,12 @@ func (i CertificateSigningRequestConditionArgs) ToCertificateSigningRequestCondi return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionOutput) } +func (i CertificateSigningRequestConditionArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestCondition] { + return pulumix.Output[CertificateSigningRequestCondition]{ + OutputState: i.ToCertificateSigningRequestConditionOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestConditionArrayInput is an input type that accepts CertificateSigningRequestConditionArray and CertificateSigningRequestConditionArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestConditionArrayInput` via: // @@ -225,6 +256,12 @@ func (i CertificateSigningRequestConditionArray) ToCertificateSigningRequestCond return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionArrayOutput) } +func (i CertificateSigningRequestConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestCondition] { + return pulumix.Output[[]CertificateSigningRequestCondition]{ + OutputState: i.ToCertificateSigningRequestConditionArrayOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestConditionOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestConditionOutput) ElementType() reflect.Type { @@ -239,6 +276,12 @@ func (o CertificateSigningRequestConditionOutput) ToCertificateSigningRequestCon return o } +func (o CertificateSigningRequestConditionOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestCondition] { + return pulumix.Output[CertificateSigningRequestCondition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the time the condition last transitioned from one status to another. If unset, when a new condition type is added or an existing condition's status is changed, the server defaults this to the current time. func (o CertificateSigningRequestConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -283,6 +326,12 @@ func (o CertificateSigningRequestConditionArrayOutput) ToCertificateSigningReque return o } +func (o CertificateSigningRequestConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestCondition] { + return pulumix.Output[[]CertificateSigningRequestCondition]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestConditionArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CertificateSigningRequestCondition { return vs[0].([]CertificateSigningRequestCondition)[vs[1].(int)] @@ -342,6 +391,12 @@ func (i CertificateSigningRequestConditionPatchArgs) ToCertificateSigningRequest return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionPatchOutput) } +func (i CertificateSigningRequestConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestConditionPatch] { + return pulumix.Output[CertificateSigningRequestConditionPatch]{ + OutputState: i.ToCertificateSigningRequestConditionPatchOutputWithContext(ctx).OutputState, + } +} + // CertificateSigningRequestConditionPatchArrayInput is an input type that accepts CertificateSigningRequestConditionPatchArray and CertificateSigningRequestConditionPatchArrayOutput values. // You can construct a concrete instance of `CertificateSigningRequestConditionPatchArrayInput` via: // @@ -367,6 +422,12 @@ func (i CertificateSigningRequestConditionPatchArray) ToCertificateSigningReques return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestConditionPatchArrayOutput) } +func (i CertificateSigningRequestConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestConditionPatch] { + return pulumix.Output[[]CertificateSigningRequestConditionPatch]{ + OutputState: i.ToCertificateSigningRequestConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestConditionPatchOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestConditionPatchOutput) ElementType() reflect.Type { @@ -381,6 +442,12 @@ func (o CertificateSigningRequestConditionPatchOutput) ToCertificateSigningReque return o } +func (o CertificateSigningRequestConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestConditionPatch] { + return pulumix.Output[CertificateSigningRequestConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the time the condition last transitioned from one status to another. If unset, when a new condition type is added or an existing condition's status is changed, the server defaults this to the current time. func (o CertificateSigningRequestConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -425,6 +492,12 @@ func (o CertificateSigningRequestConditionPatchArrayOutput) ToCertificateSigning return o } +func (o CertificateSigningRequestConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CertificateSigningRequestConditionPatch] { + return pulumix.Output[[]CertificateSigningRequestConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestConditionPatchArrayOutput) Index(i pulumi.IntInput) CertificateSigningRequestConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CertificateSigningRequestConditionPatch { return vs[0].([]CertificateSigningRequestConditionPatch)[vs[1].(int)] @@ -472,6 +545,12 @@ func (i CertificateSigningRequestListTypeArgs) ToCertificateSigningRequestListTy return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestListTypeOutput) } +func (i CertificateSigningRequestListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestListType] { + return pulumix.Output[CertificateSigningRequestListType]{ + OutputState: i.ToCertificateSigningRequestListTypeOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestListTypeOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestListTypeOutput) ElementType() reflect.Type { @@ -486,6 +565,12 @@ func (o CertificateSigningRequestListTypeOutput) ToCertificateSigningRequestList return o } +func (o CertificateSigningRequestListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestListType] { + return pulumix.Output[CertificateSigningRequestListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -553,6 +638,12 @@ func (i CertificateSigningRequestPatchTypeArgs) ToCertificateSigningRequestPatch return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestPatchTypeOutput) } +func (i CertificateSigningRequestPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestPatchType] { + return pulumix.Output[CertificateSigningRequestPatchType]{ + OutputState: i.ToCertificateSigningRequestPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Describes a certificate signing request type CertificateSigningRequestPatchTypeOutput struct{ *pulumi.OutputState } @@ -568,6 +659,12 @@ func (o CertificateSigningRequestPatchTypeOutput) ToCertificateSigningRequestPat return o } +func (o CertificateSigningRequestPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestPatchType] { + return pulumix.Output[CertificateSigningRequestPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CertificateSigningRequestPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -665,6 +762,12 @@ func (i CertificateSigningRequestSpecArgs) ToCertificateSigningRequestSpecOutput return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecOutput) } +func (i CertificateSigningRequestSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpec] { + return pulumix.Output[CertificateSigningRequestSpec]{ + OutputState: i.ToCertificateSigningRequestSpecOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestSpecArgs) ToCertificateSigningRequestSpecPtrOutput() CertificateSigningRequestSpecPtrOutput { return i.ToCertificateSigningRequestSpecPtrOutputWithContext(context.Background()) } @@ -706,6 +809,12 @@ func (i *certificateSigningRequestSpecPtrType) ToCertificateSigningRequestSpecPt return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecPtrOutput) } +func (i *certificateSigningRequestSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestSpec] { + return pulumix.Output[*CertificateSigningRequestSpec]{ + OutputState: i.ToCertificateSigningRequestSpecPtrOutputWithContext(ctx).OutputState, + } +} + // This information is immutable after the request is created. Only the Request and Usages fields can be set on creation, other fields are derived by Kubernetes and cannot be modified by users. type CertificateSigningRequestSpecOutput struct{ *pulumi.OutputState } @@ -731,6 +840,12 @@ func (o CertificateSigningRequestSpecOutput) ToCertificateSigningRequestSpecPtrO }).(CertificateSigningRequestSpecPtrOutput) } +func (o CertificateSigningRequestSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpec] { + return pulumix.Output[CertificateSigningRequestSpec]{ + OutputState: o.OutputState, + } +} + // Extra information about the requesting user. See user.Info interface for details. func (o CertificateSigningRequestSpecOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v CertificateSigningRequestSpec) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -788,6 +903,12 @@ func (o CertificateSigningRequestSpecPtrOutput) ToCertificateSigningRequestSpecP return o } +func (o CertificateSigningRequestSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestSpec] { + return pulumix.Output[*CertificateSigningRequestSpec]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestSpecPtrOutput) Elem() CertificateSigningRequestSpecOutput { return o.ApplyT(func(v *CertificateSigningRequestSpec) CertificateSigningRequestSpec { if v != nil { @@ -949,6 +1070,12 @@ func (i CertificateSigningRequestSpecPatchArgs) ToCertificateSigningRequestSpecP return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecPatchOutput) } +func (i CertificateSigningRequestSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpecPatch] { + return pulumix.Output[CertificateSigningRequestSpecPatch]{ + OutputState: i.ToCertificateSigningRequestSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestSpecPatchArgs) ToCertificateSigningRequestSpecPatchPtrOutput() CertificateSigningRequestSpecPatchPtrOutput { return i.ToCertificateSigningRequestSpecPatchPtrOutputWithContext(context.Background()) } @@ -990,6 +1117,12 @@ func (i *certificateSigningRequestSpecPatchPtrType) ToCertificateSigningRequestS return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestSpecPatchPtrOutput) } +func (i *certificateSigningRequestSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestSpecPatch] { + return pulumix.Output[*CertificateSigningRequestSpecPatch]{ + OutputState: i.ToCertificateSigningRequestSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // This information is immutable after the request is created. Only the Request and Usages fields can be set on creation, other fields are derived by Kubernetes and cannot be modified by users. type CertificateSigningRequestSpecPatchOutput struct{ *pulumi.OutputState } @@ -1015,6 +1148,12 @@ func (o CertificateSigningRequestSpecPatchOutput) ToCertificateSigningRequestSpe }).(CertificateSigningRequestSpecPatchPtrOutput) } +func (o CertificateSigningRequestSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestSpecPatch] { + return pulumix.Output[CertificateSigningRequestSpecPatch]{ + OutputState: o.OutputState, + } +} + // Extra information about the requesting user. See user.Info interface for details. func (o CertificateSigningRequestSpecPatchOutput) Extra() pulumi.StringArrayMapOutput { return o.ApplyT(func(v CertificateSigningRequestSpecPatch) map[string][]string { return v.Extra }).(pulumi.StringArrayMapOutput) @@ -1072,6 +1211,12 @@ func (o CertificateSigningRequestSpecPatchPtrOutput) ToCertificateSigningRequest return o } +func (o CertificateSigningRequestSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestSpecPatch] { + return pulumix.Output[*CertificateSigningRequestSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestSpecPatchPtrOutput) Elem() CertificateSigningRequestSpecPatchOutput { return o.ApplyT(func(v *CertificateSigningRequestSpecPatch) CertificateSigningRequestSpecPatch { if v != nil { @@ -1197,6 +1342,12 @@ func (i CertificateSigningRequestStatusArgs) ToCertificateSigningRequestStatusOu return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusOutput) } +func (i CertificateSigningRequestStatusArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatus] { + return pulumix.Output[CertificateSigningRequestStatus]{ + OutputState: i.ToCertificateSigningRequestStatusOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestStatusArgs) ToCertificateSigningRequestStatusPtrOutput() CertificateSigningRequestStatusPtrOutput { return i.ToCertificateSigningRequestStatusPtrOutputWithContext(context.Background()) } @@ -1238,6 +1389,12 @@ func (i *certificateSigningRequestStatusPtrType) ToCertificateSigningRequestStat return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusPtrOutput) } +func (i *certificateSigningRequestStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatus] { + return pulumix.Output[*CertificateSigningRequestStatus]{ + OutputState: i.ToCertificateSigningRequestStatusPtrOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestStatusOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestStatusOutput) ElementType() reflect.Type { @@ -1262,6 +1419,12 @@ func (o CertificateSigningRequestStatusOutput) ToCertificateSigningRequestStatus }).(CertificateSigningRequestStatusPtrOutput) } +func (o CertificateSigningRequestStatusOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatus] { + return pulumix.Output[CertificateSigningRequestStatus]{ + OutputState: o.OutputState, + } +} + // If request was approved, the controller will place the issued certificate here. func (o CertificateSigningRequestStatusOutput) Certificate() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestStatus) *string { return v.Certificate }).(pulumi.StringPtrOutput) @@ -1286,6 +1449,12 @@ func (o CertificateSigningRequestStatusPtrOutput) ToCertificateSigningRequestSta return o } +func (o CertificateSigningRequestStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatus] { + return pulumix.Output[*CertificateSigningRequestStatus]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestStatusPtrOutput) Elem() CertificateSigningRequestStatusOutput { return o.ApplyT(func(v *CertificateSigningRequestStatus) CertificateSigningRequestStatus { if v != nil { @@ -1353,6 +1522,12 @@ func (i CertificateSigningRequestStatusPatchArgs) ToCertificateSigningRequestSta return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusPatchOutput) } +func (i CertificateSigningRequestStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatusPatch] { + return pulumix.Output[CertificateSigningRequestStatusPatch]{ + OutputState: i.ToCertificateSigningRequestStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i CertificateSigningRequestStatusPatchArgs) ToCertificateSigningRequestStatusPatchPtrOutput() CertificateSigningRequestStatusPatchPtrOutput { return i.ToCertificateSigningRequestStatusPatchPtrOutputWithContext(context.Background()) } @@ -1394,6 +1569,12 @@ func (i *certificateSigningRequestStatusPatchPtrType) ToCertificateSigningReques return pulumi.ToOutputWithContext(ctx, i).(CertificateSigningRequestStatusPatchPtrOutput) } +func (i *certificateSigningRequestStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatusPatch] { + return pulumix.Output[*CertificateSigningRequestStatusPatch]{ + OutputState: i.ToCertificateSigningRequestStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + type CertificateSigningRequestStatusPatchOutput struct{ *pulumi.OutputState } func (CertificateSigningRequestStatusPatchOutput) ElementType() reflect.Type { @@ -1418,6 +1599,12 @@ func (o CertificateSigningRequestStatusPatchOutput) ToCertificateSigningRequestS }).(CertificateSigningRequestStatusPatchPtrOutput) } +func (o CertificateSigningRequestStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CertificateSigningRequestStatusPatch] { + return pulumix.Output[CertificateSigningRequestStatusPatch]{ + OutputState: o.OutputState, + } +} + // If request was approved, the controller will place the issued certificate here. func (o CertificateSigningRequestStatusPatchOutput) Certificate() pulumi.StringPtrOutput { return o.ApplyT(func(v CertificateSigningRequestStatusPatch) *string { return v.Certificate }).(pulumi.StringPtrOutput) @@ -1444,6 +1631,12 @@ func (o CertificateSigningRequestStatusPatchPtrOutput) ToCertificateSigningReque return o } +func (o CertificateSigningRequestStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CertificateSigningRequestStatusPatch] { + return pulumix.Output[*CertificateSigningRequestStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o CertificateSigningRequestStatusPatchPtrOutput) Elem() CertificateSigningRequestStatusPatchOutput { return o.ApplyT(func(v *CertificateSigningRequestStatusPatch) CertificateSigningRequestStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/coordination/v1/lease.go b/sdk/go/kubernetes/coordination/v1/lease.go index c153425bd7..fe1c56ff55 100644 --- a/sdk/go/kubernetes/coordination/v1/lease.go +++ b/sdk/go/kubernetes/coordination/v1/lease.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Lease defines a lease concept. @@ -119,6 +120,12 @@ func (i *Lease) ToLeaseOutputWithContext(ctx context.Context) LeaseOutput { return pulumi.ToOutputWithContext(ctx, i).(LeaseOutput) } +func (i *Lease) ToOutput(ctx context.Context) pulumix.Output[*Lease] { + return pulumix.Output[*Lease]{ + OutputState: i.ToLeaseOutputWithContext(ctx).OutputState, + } +} + // LeaseArrayInput is an input type that accepts LeaseArray and LeaseArrayOutput values. // You can construct a concrete instance of `LeaseArrayInput` via: // @@ -144,6 +151,12 @@ func (i LeaseArray) ToLeaseArrayOutputWithContext(ctx context.Context) LeaseArra return pulumi.ToOutputWithContext(ctx, i).(LeaseArrayOutput) } +func (i LeaseArray) ToOutput(ctx context.Context) pulumix.Output[[]*Lease] { + return pulumix.Output[[]*Lease]{ + OutputState: i.ToLeaseArrayOutputWithContext(ctx).OutputState, + } +} + // LeaseMapInput is an input type that accepts LeaseMap and LeaseMapOutput values. // You can construct a concrete instance of `LeaseMapInput` via: // @@ -169,6 +182,12 @@ func (i LeaseMap) ToLeaseMapOutputWithContext(ctx context.Context) LeaseMapOutpu return pulumi.ToOutputWithContext(ctx, i).(LeaseMapOutput) } +func (i LeaseMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Lease] { + return pulumix.Output[map[string]*Lease]{ + OutputState: i.ToLeaseMapOutputWithContext(ctx).OutputState, + } +} + type LeaseOutput struct{ *pulumi.OutputState } func (LeaseOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o LeaseOutput) ToLeaseOutputWithContext(ctx context.Context) LeaseOutput { return o } +func (o LeaseOutput) ToOutput(ctx context.Context) pulumix.Output[*Lease] { + return pulumix.Output[*Lease]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Lease) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o LeaseArrayOutput) ToLeaseArrayOutputWithContext(ctx context.Context) Lea return o } +func (o LeaseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Lease] { + return pulumix.Output[[]*Lease]{ + OutputState: o.OutputState, + } +} + func (o LeaseArrayOutput) Index(i pulumi.IntInput) LeaseOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Lease { return vs[0].([]*Lease)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o LeaseMapOutput) ToLeaseMapOutputWithContext(ctx context.Context) LeaseMa return o } +func (o LeaseMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Lease] { + return pulumix.Output[map[string]*Lease]{ + OutputState: o.OutputState, + } +} + func (o LeaseMapOutput) MapIndex(k pulumi.StringInput) LeaseOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Lease { return vs[0].(map[string]*Lease)[vs[1].(string)] diff --git a/sdk/go/kubernetes/coordination/v1/leaseList.go b/sdk/go/kubernetes/coordination/v1/leaseList.go index ed8649f82a..926e22d53b 100644 --- a/sdk/go/kubernetes/coordination/v1/leaseList.go +++ b/sdk/go/kubernetes/coordination/v1/leaseList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // LeaseList is a list of Lease objects. @@ -117,6 +118,12 @@ func (i *LeaseList) ToLeaseListOutputWithContext(ctx context.Context) LeaseListO return pulumi.ToOutputWithContext(ctx, i).(LeaseListOutput) } +func (i *LeaseList) ToOutput(ctx context.Context) pulumix.Output[*LeaseList] { + return pulumix.Output[*LeaseList]{ + OutputState: i.ToLeaseListOutputWithContext(ctx).OutputState, + } +} + // LeaseListArrayInput is an input type that accepts LeaseListArray and LeaseListArrayOutput values. // You can construct a concrete instance of `LeaseListArrayInput` via: // @@ -142,6 +149,12 @@ func (i LeaseListArray) ToLeaseListArrayOutputWithContext(ctx context.Context) L return pulumi.ToOutputWithContext(ctx, i).(LeaseListArrayOutput) } +func (i LeaseListArray) ToOutput(ctx context.Context) pulumix.Output[[]*LeaseList] { + return pulumix.Output[[]*LeaseList]{ + OutputState: i.ToLeaseListArrayOutputWithContext(ctx).OutputState, + } +} + // LeaseListMapInput is an input type that accepts LeaseListMap and LeaseListMapOutput values. // You can construct a concrete instance of `LeaseListMapInput` via: // @@ -167,6 +180,12 @@ func (i LeaseListMap) ToLeaseListMapOutputWithContext(ctx context.Context) Lease return pulumi.ToOutputWithContext(ctx, i).(LeaseListMapOutput) } +func (i LeaseListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeaseList] { + return pulumix.Output[map[string]*LeaseList]{ + OutputState: i.ToLeaseListMapOutputWithContext(ctx).OutputState, + } +} + type LeaseListOutput struct{ *pulumi.OutputState } func (LeaseListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o LeaseListOutput) ToLeaseListOutputWithContext(ctx context.Context) Lease return o } +func (o LeaseListOutput) ToOutput(ctx context.Context) pulumix.Output[*LeaseList] { + return pulumix.Output[*LeaseList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *LeaseList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o LeaseListArrayOutput) ToLeaseListArrayOutputWithContext(ctx context.Cont return o } +func (o LeaseListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LeaseList] { + return pulumix.Output[[]*LeaseList]{ + OutputState: o.OutputState, + } +} + func (o LeaseListArrayOutput) Index(i pulumi.IntInput) LeaseListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LeaseList { return vs[0].([]*LeaseList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o LeaseListMapOutput) ToLeaseListMapOutputWithContext(ctx context.Context) return o } +func (o LeaseListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeaseList] { + return pulumix.Output[map[string]*LeaseList]{ + OutputState: o.OutputState, + } +} + func (o LeaseListMapOutput) MapIndex(k pulumi.StringInput) LeaseListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LeaseList { return vs[0].(map[string]*LeaseList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/coordination/v1/leasePatch.go b/sdk/go/kubernetes/coordination/v1/leasePatch.go index 9ab24933f7..000737d646 100644 --- a/sdk/go/kubernetes/coordination/v1/leasePatch.go +++ b/sdk/go/kubernetes/coordination/v1/leasePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *LeasePatch) ToLeasePatchOutputWithContext(ctx context.Context) LeasePat return pulumi.ToOutputWithContext(ctx, i).(LeasePatchOutput) } +func (i *LeasePatch) ToOutput(ctx context.Context) pulumix.Output[*LeasePatch] { + return pulumix.Output[*LeasePatch]{ + OutputState: i.ToLeasePatchOutputWithContext(ctx).OutputState, + } +} + // LeasePatchArrayInput is an input type that accepts LeasePatchArray and LeasePatchArrayOutput values. // You can construct a concrete instance of `LeasePatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i LeasePatchArray) ToLeasePatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LeasePatchArrayOutput) } +func (i LeasePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*LeasePatch] { + return pulumix.Output[[]*LeasePatch]{ + OutputState: i.ToLeasePatchArrayOutputWithContext(ctx).OutputState, + } +} + // LeasePatchMapInput is an input type that accepts LeasePatchMap and LeasePatchMapOutput values. // You can construct a concrete instance of `LeasePatchMapInput` via: // @@ -175,6 +188,12 @@ func (i LeasePatchMap) ToLeasePatchMapOutputWithContext(ctx context.Context) Lea return pulumi.ToOutputWithContext(ctx, i).(LeasePatchMapOutput) } +func (i LeasePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeasePatch] { + return pulumix.Output[map[string]*LeasePatch]{ + OutputState: i.ToLeasePatchMapOutputWithContext(ctx).OutputState, + } +} + type LeasePatchOutput struct{ *pulumi.OutputState } func (LeasePatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o LeasePatchOutput) ToLeasePatchOutputWithContext(ctx context.Context) Lea return o } +func (o LeasePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*LeasePatch] { + return pulumix.Output[*LeasePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeasePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *LeasePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o LeasePatchArrayOutput) ToLeasePatchArrayOutputWithContext(ctx context.Co return o } +func (o LeasePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LeasePatch] { + return pulumix.Output[[]*LeasePatch]{ + OutputState: o.OutputState, + } +} + func (o LeasePatchArrayOutput) Index(i pulumi.IntInput) LeasePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LeasePatch { return vs[0].([]*LeasePatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o LeasePatchMapOutput) ToLeasePatchMapOutputWithContext(ctx context.Contex return o } +func (o LeasePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeasePatch] { + return pulumix.Output[map[string]*LeasePatch]{ + OutputState: o.OutputState, + } +} + func (o LeasePatchMapOutput) MapIndex(k pulumi.StringInput) LeasePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LeasePatch { return vs[0].(map[string]*LeasePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/coordination/v1/pulumiTypes.go b/sdk/go/kubernetes/coordination/v1/pulumiTypes.go index 316dcd3c27..ed042972c1 100644 --- a/sdk/go/kubernetes/coordination/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/coordination/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -61,6 +62,12 @@ func (i LeaseTypeArgs) ToLeaseTypeOutputWithContext(ctx context.Context) LeaseTy return pulumi.ToOutputWithContext(ctx, i).(LeaseTypeOutput) } +func (i LeaseTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseType] { + return pulumix.Output[LeaseType]{ + OutputState: i.ToLeaseTypeOutputWithContext(ctx).OutputState, + } +} + // LeaseTypeArrayInput is an input type that accepts LeaseTypeArray and LeaseTypeArrayOutput values. // You can construct a concrete instance of `LeaseTypeArrayInput` via: // @@ -86,6 +93,12 @@ func (i LeaseTypeArray) ToLeaseTypeArrayOutputWithContext(ctx context.Context) L return pulumi.ToOutputWithContext(ctx, i).(LeaseTypeArrayOutput) } +func (i LeaseTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]LeaseType] { + return pulumix.Output[[]LeaseType]{ + OutputState: i.ToLeaseTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Lease defines a lease concept. type LeaseTypeOutput struct{ *pulumi.OutputState } @@ -101,6 +114,12 @@ func (o LeaseTypeOutput) ToLeaseTypeOutputWithContext(ctx context.Context) Lease return o } +func (o LeaseTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseType] { + return pulumix.Output[LeaseType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -135,6 +154,12 @@ func (o LeaseTypeArrayOutput) ToLeaseTypeArrayOutputWithContext(ctx context.Cont return o } +func (o LeaseTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LeaseType] { + return pulumix.Output[[]LeaseType]{ + OutputState: o.OutputState, + } +} + func (o LeaseTypeArrayOutput) Index(i pulumi.IntInput) LeaseTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LeaseType { return vs[0].([]LeaseType)[vs[1].(int)] @@ -188,6 +213,12 @@ func (i LeaseListTypeArgs) ToLeaseListTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LeaseListTypeOutput) } +func (i LeaseListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseListType] { + return pulumix.Output[LeaseListType]{ + OutputState: i.ToLeaseListTypeOutputWithContext(ctx).OutputState, + } +} + // LeaseList is a list of Lease objects. type LeaseListTypeOutput struct{ *pulumi.OutputState } @@ -203,6 +234,12 @@ func (o LeaseListTypeOutput) ToLeaseListTypeOutputWithContext(ctx context.Contex return o } +func (o LeaseListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseListType] { + return pulumix.Output[LeaseListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -270,6 +307,12 @@ func (i LeasePatchTypeArgs) ToLeasePatchTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LeasePatchTypeOutput) } +func (i LeasePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LeasePatchType] { + return pulumix.Output[LeasePatchType]{ + OutputState: i.ToLeasePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Lease defines a lease concept. type LeasePatchTypeOutput struct{ *pulumi.OutputState } @@ -285,6 +328,12 @@ func (o LeasePatchTypeOutput) ToLeasePatchTypeOutputWithContext(ctx context.Cont return o } +func (o LeasePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LeasePatchType] { + return pulumix.Output[LeasePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeasePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LeasePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -356,6 +405,12 @@ func (i LeaseSpecArgs) ToLeaseSpecOutputWithContext(ctx context.Context) LeaseSp return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecOutput) } +func (i LeaseSpecArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseSpec] { + return pulumix.Output[LeaseSpec]{ + OutputState: i.ToLeaseSpecOutputWithContext(ctx).OutputState, + } +} + func (i LeaseSpecArgs) ToLeaseSpecPtrOutput() LeaseSpecPtrOutput { return i.ToLeaseSpecPtrOutputWithContext(context.Background()) } @@ -397,6 +452,12 @@ func (i *leaseSpecPtrType) ToLeaseSpecPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecPtrOutput) } +func (i *leaseSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpec] { + return pulumix.Output[*LeaseSpec]{ + OutputState: i.ToLeaseSpecPtrOutputWithContext(ctx).OutputState, + } +} + // LeaseSpec is a specification of a Lease. type LeaseSpecOutput struct{ *pulumi.OutputState } @@ -422,6 +483,12 @@ func (o LeaseSpecOutput) ToLeaseSpecPtrOutputWithContext(ctx context.Context) Le }).(LeaseSpecPtrOutput) } +func (o LeaseSpecOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseSpec] { + return pulumix.Output[LeaseSpec]{ + OutputState: o.OutputState, + } +} + // acquireTime is a time when the current lease was acquired. func (o LeaseSpecOutput) AcquireTime() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseSpec) *string { return v.AcquireTime }).(pulumi.StringPtrOutput) @@ -461,6 +528,12 @@ func (o LeaseSpecPtrOutput) ToLeaseSpecPtrOutputWithContext(ctx context.Context) return o } +func (o LeaseSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpec] { + return pulumix.Output[*LeaseSpec]{ + OutputState: o.OutputState, + } +} + func (o LeaseSpecPtrOutput) Elem() LeaseSpecOutput { return o.ApplyT(func(v *LeaseSpec) LeaseSpec { if v != nil { @@ -572,6 +645,12 @@ func (i LeaseSpecPatchArgs) ToLeaseSpecPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecPatchOutput) } +func (i LeaseSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseSpecPatch] { + return pulumix.Output[LeaseSpecPatch]{ + OutputState: i.ToLeaseSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i LeaseSpecPatchArgs) ToLeaseSpecPatchPtrOutput() LeaseSpecPatchPtrOutput { return i.ToLeaseSpecPatchPtrOutputWithContext(context.Background()) } @@ -613,6 +692,12 @@ func (i *leaseSpecPatchPtrType) ToLeaseSpecPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecPatchPtrOutput) } +func (i *leaseSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpecPatch] { + return pulumix.Output[*LeaseSpecPatch]{ + OutputState: i.ToLeaseSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LeaseSpec is a specification of a Lease. type LeaseSpecPatchOutput struct{ *pulumi.OutputState } @@ -638,6 +723,12 @@ func (o LeaseSpecPatchOutput) ToLeaseSpecPatchPtrOutputWithContext(ctx context.C }).(LeaseSpecPatchPtrOutput) } +func (o LeaseSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseSpecPatch] { + return pulumix.Output[LeaseSpecPatch]{ + OutputState: o.OutputState, + } +} + // acquireTime is a time when the current lease was acquired. func (o LeaseSpecPatchOutput) AcquireTime() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseSpecPatch) *string { return v.AcquireTime }).(pulumi.StringPtrOutput) @@ -677,6 +768,12 @@ func (o LeaseSpecPatchPtrOutput) ToLeaseSpecPatchPtrOutputWithContext(ctx contex return o } +func (o LeaseSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpecPatch] { + return pulumix.Output[*LeaseSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o LeaseSpecPatchPtrOutput) Elem() LeaseSpecPatchOutput { return o.ApplyT(func(v *LeaseSpecPatch) LeaseSpecPatch { if v != nil { diff --git a/sdk/go/kubernetes/coordination/v1beta1/lease.go b/sdk/go/kubernetes/coordination/v1beta1/lease.go index ba07b19794..79720182df 100644 --- a/sdk/go/kubernetes/coordination/v1beta1/lease.go +++ b/sdk/go/kubernetes/coordination/v1beta1/lease.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Lease defines a lease concept. @@ -119,6 +120,12 @@ func (i *Lease) ToLeaseOutputWithContext(ctx context.Context) LeaseOutput { return pulumi.ToOutputWithContext(ctx, i).(LeaseOutput) } +func (i *Lease) ToOutput(ctx context.Context) pulumix.Output[*Lease] { + return pulumix.Output[*Lease]{ + OutputState: i.ToLeaseOutputWithContext(ctx).OutputState, + } +} + // LeaseArrayInput is an input type that accepts LeaseArray and LeaseArrayOutput values. // You can construct a concrete instance of `LeaseArrayInput` via: // @@ -144,6 +151,12 @@ func (i LeaseArray) ToLeaseArrayOutputWithContext(ctx context.Context) LeaseArra return pulumi.ToOutputWithContext(ctx, i).(LeaseArrayOutput) } +func (i LeaseArray) ToOutput(ctx context.Context) pulumix.Output[[]*Lease] { + return pulumix.Output[[]*Lease]{ + OutputState: i.ToLeaseArrayOutputWithContext(ctx).OutputState, + } +} + // LeaseMapInput is an input type that accepts LeaseMap and LeaseMapOutput values. // You can construct a concrete instance of `LeaseMapInput` via: // @@ -169,6 +182,12 @@ func (i LeaseMap) ToLeaseMapOutputWithContext(ctx context.Context) LeaseMapOutpu return pulumi.ToOutputWithContext(ctx, i).(LeaseMapOutput) } +func (i LeaseMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Lease] { + return pulumix.Output[map[string]*Lease]{ + OutputState: i.ToLeaseMapOutputWithContext(ctx).OutputState, + } +} + type LeaseOutput struct{ *pulumi.OutputState } func (LeaseOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o LeaseOutput) ToLeaseOutputWithContext(ctx context.Context) LeaseOutput { return o } +func (o LeaseOutput) ToOutput(ctx context.Context) pulumix.Output[*Lease] { + return pulumix.Output[*Lease]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Lease) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o LeaseArrayOutput) ToLeaseArrayOutputWithContext(ctx context.Context) Lea return o } +func (o LeaseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Lease] { + return pulumix.Output[[]*Lease]{ + OutputState: o.OutputState, + } +} + func (o LeaseArrayOutput) Index(i pulumi.IntInput) LeaseOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Lease { return vs[0].([]*Lease)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o LeaseMapOutput) ToLeaseMapOutputWithContext(ctx context.Context) LeaseMa return o } +func (o LeaseMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Lease] { + return pulumix.Output[map[string]*Lease]{ + OutputState: o.OutputState, + } +} + func (o LeaseMapOutput) MapIndex(k pulumi.StringInput) LeaseOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Lease { return vs[0].(map[string]*Lease)[vs[1].(string)] diff --git a/sdk/go/kubernetes/coordination/v1beta1/leaseList.go b/sdk/go/kubernetes/coordination/v1beta1/leaseList.go index 2c2b9a604e..03101612a8 100644 --- a/sdk/go/kubernetes/coordination/v1beta1/leaseList.go +++ b/sdk/go/kubernetes/coordination/v1beta1/leaseList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // LeaseList is a list of Lease objects. @@ -117,6 +118,12 @@ func (i *LeaseList) ToLeaseListOutputWithContext(ctx context.Context) LeaseListO return pulumi.ToOutputWithContext(ctx, i).(LeaseListOutput) } +func (i *LeaseList) ToOutput(ctx context.Context) pulumix.Output[*LeaseList] { + return pulumix.Output[*LeaseList]{ + OutputState: i.ToLeaseListOutputWithContext(ctx).OutputState, + } +} + // LeaseListArrayInput is an input type that accepts LeaseListArray and LeaseListArrayOutput values. // You can construct a concrete instance of `LeaseListArrayInput` via: // @@ -142,6 +149,12 @@ func (i LeaseListArray) ToLeaseListArrayOutputWithContext(ctx context.Context) L return pulumi.ToOutputWithContext(ctx, i).(LeaseListArrayOutput) } +func (i LeaseListArray) ToOutput(ctx context.Context) pulumix.Output[[]*LeaseList] { + return pulumix.Output[[]*LeaseList]{ + OutputState: i.ToLeaseListArrayOutputWithContext(ctx).OutputState, + } +} + // LeaseListMapInput is an input type that accepts LeaseListMap and LeaseListMapOutput values. // You can construct a concrete instance of `LeaseListMapInput` via: // @@ -167,6 +180,12 @@ func (i LeaseListMap) ToLeaseListMapOutputWithContext(ctx context.Context) Lease return pulumi.ToOutputWithContext(ctx, i).(LeaseListMapOutput) } +func (i LeaseListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeaseList] { + return pulumix.Output[map[string]*LeaseList]{ + OutputState: i.ToLeaseListMapOutputWithContext(ctx).OutputState, + } +} + type LeaseListOutput struct{ *pulumi.OutputState } func (LeaseListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o LeaseListOutput) ToLeaseListOutputWithContext(ctx context.Context) Lease return o } +func (o LeaseListOutput) ToOutput(ctx context.Context) pulumix.Output[*LeaseList] { + return pulumix.Output[*LeaseList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *LeaseList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o LeaseListArrayOutput) ToLeaseListArrayOutputWithContext(ctx context.Cont return o } +func (o LeaseListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LeaseList] { + return pulumix.Output[[]*LeaseList]{ + OutputState: o.OutputState, + } +} + func (o LeaseListArrayOutput) Index(i pulumi.IntInput) LeaseListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LeaseList { return vs[0].([]*LeaseList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o LeaseListMapOutput) ToLeaseListMapOutputWithContext(ctx context.Context) return o } +func (o LeaseListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeaseList] { + return pulumix.Output[map[string]*LeaseList]{ + OutputState: o.OutputState, + } +} + func (o LeaseListMapOutput) MapIndex(k pulumi.StringInput) LeaseListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LeaseList { return vs[0].(map[string]*LeaseList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/coordination/v1beta1/leasePatch.go b/sdk/go/kubernetes/coordination/v1beta1/leasePatch.go index cc42467d97..d378c11a7d 100644 --- a/sdk/go/kubernetes/coordination/v1beta1/leasePatch.go +++ b/sdk/go/kubernetes/coordination/v1beta1/leasePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *LeasePatch) ToLeasePatchOutputWithContext(ctx context.Context) LeasePat return pulumi.ToOutputWithContext(ctx, i).(LeasePatchOutput) } +func (i *LeasePatch) ToOutput(ctx context.Context) pulumix.Output[*LeasePatch] { + return pulumix.Output[*LeasePatch]{ + OutputState: i.ToLeasePatchOutputWithContext(ctx).OutputState, + } +} + // LeasePatchArrayInput is an input type that accepts LeasePatchArray and LeasePatchArrayOutput values. // You can construct a concrete instance of `LeasePatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i LeasePatchArray) ToLeasePatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LeasePatchArrayOutput) } +func (i LeasePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*LeasePatch] { + return pulumix.Output[[]*LeasePatch]{ + OutputState: i.ToLeasePatchArrayOutputWithContext(ctx).OutputState, + } +} + // LeasePatchMapInput is an input type that accepts LeasePatchMap and LeasePatchMapOutput values. // You can construct a concrete instance of `LeasePatchMapInput` via: // @@ -175,6 +188,12 @@ func (i LeasePatchMap) ToLeasePatchMapOutputWithContext(ctx context.Context) Lea return pulumi.ToOutputWithContext(ctx, i).(LeasePatchMapOutput) } +func (i LeasePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeasePatch] { + return pulumix.Output[map[string]*LeasePatch]{ + OutputState: i.ToLeasePatchMapOutputWithContext(ctx).OutputState, + } +} + type LeasePatchOutput struct{ *pulumi.OutputState } func (LeasePatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o LeasePatchOutput) ToLeasePatchOutputWithContext(ctx context.Context) Lea return o } +func (o LeasePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*LeasePatch] { + return pulumix.Output[*LeasePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeasePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *LeasePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o LeasePatchArrayOutput) ToLeasePatchArrayOutputWithContext(ctx context.Co return o } +func (o LeasePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LeasePatch] { + return pulumix.Output[[]*LeasePatch]{ + OutputState: o.OutputState, + } +} + func (o LeasePatchArrayOutput) Index(i pulumi.IntInput) LeasePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LeasePatch { return vs[0].([]*LeasePatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o LeasePatchMapOutput) ToLeasePatchMapOutputWithContext(ctx context.Contex return o } +func (o LeasePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LeasePatch] { + return pulumix.Output[map[string]*LeasePatch]{ + OutputState: o.OutputState, + } +} + func (o LeasePatchMapOutput) MapIndex(k pulumi.StringInput) LeasePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LeasePatch { return vs[0].(map[string]*LeasePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/coordination/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/coordination/v1beta1/pulumiTypes.go index ae674dd9cd..ab4e0a13e7 100644 --- a/sdk/go/kubernetes/coordination/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/coordination/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -61,6 +62,12 @@ func (i LeaseTypeArgs) ToLeaseTypeOutputWithContext(ctx context.Context) LeaseTy return pulumi.ToOutputWithContext(ctx, i).(LeaseTypeOutput) } +func (i LeaseTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseType] { + return pulumix.Output[LeaseType]{ + OutputState: i.ToLeaseTypeOutputWithContext(ctx).OutputState, + } +} + // LeaseTypeArrayInput is an input type that accepts LeaseTypeArray and LeaseTypeArrayOutput values. // You can construct a concrete instance of `LeaseTypeArrayInput` via: // @@ -86,6 +93,12 @@ func (i LeaseTypeArray) ToLeaseTypeArrayOutputWithContext(ctx context.Context) L return pulumi.ToOutputWithContext(ctx, i).(LeaseTypeArrayOutput) } +func (i LeaseTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]LeaseType] { + return pulumix.Output[[]LeaseType]{ + OutputState: i.ToLeaseTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Lease defines a lease concept. type LeaseTypeOutput struct{ *pulumi.OutputState } @@ -101,6 +114,12 @@ func (o LeaseTypeOutput) ToLeaseTypeOutputWithContext(ctx context.Context) Lease return o } +func (o LeaseTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseType] { + return pulumix.Output[LeaseType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -135,6 +154,12 @@ func (o LeaseTypeArrayOutput) ToLeaseTypeArrayOutputWithContext(ctx context.Cont return o } +func (o LeaseTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LeaseType] { + return pulumix.Output[[]LeaseType]{ + OutputState: o.OutputState, + } +} + func (o LeaseTypeArrayOutput) Index(i pulumi.IntInput) LeaseTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LeaseType { return vs[0].([]LeaseType)[vs[1].(int)] @@ -188,6 +213,12 @@ func (i LeaseListTypeArgs) ToLeaseListTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LeaseListTypeOutput) } +func (i LeaseListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseListType] { + return pulumix.Output[LeaseListType]{ + OutputState: i.ToLeaseListTypeOutputWithContext(ctx).OutputState, + } +} + // LeaseList is a list of Lease objects. type LeaseListTypeOutput struct{ *pulumi.OutputState } @@ -203,6 +234,12 @@ func (o LeaseListTypeOutput) ToLeaseListTypeOutputWithContext(ctx context.Contex return o } +func (o LeaseListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseListType] { + return pulumix.Output[LeaseListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeaseListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -270,6 +307,12 @@ func (i LeasePatchTypeArgs) ToLeasePatchTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LeasePatchTypeOutput) } +func (i LeasePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LeasePatchType] { + return pulumix.Output[LeasePatchType]{ + OutputState: i.ToLeasePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Lease defines a lease concept. type LeasePatchTypeOutput struct{ *pulumi.OutputState } @@ -285,6 +328,12 @@ func (o LeasePatchTypeOutput) ToLeasePatchTypeOutputWithContext(ctx context.Cont return o } +func (o LeasePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LeasePatchType] { + return pulumix.Output[LeasePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LeasePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LeasePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -356,6 +405,12 @@ func (i LeaseSpecArgs) ToLeaseSpecOutputWithContext(ctx context.Context) LeaseSp return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecOutput) } +func (i LeaseSpecArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseSpec] { + return pulumix.Output[LeaseSpec]{ + OutputState: i.ToLeaseSpecOutputWithContext(ctx).OutputState, + } +} + func (i LeaseSpecArgs) ToLeaseSpecPtrOutput() LeaseSpecPtrOutput { return i.ToLeaseSpecPtrOutputWithContext(context.Background()) } @@ -397,6 +452,12 @@ func (i *leaseSpecPtrType) ToLeaseSpecPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecPtrOutput) } +func (i *leaseSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpec] { + return pulumix.Output[*LeaseSpec]{ + OutputState: i.ToLeaseSpecPtrOutputWithContext(ctx).OutputState, + } +} + // LeaseSpec is a specification of a Lease. type LeaseSpecOutput struct{ *pulumi.OutputState } @@ -422,6 +483,12 @@ func (o LeaseSpecOutput) ToLeaseSpecPtrOutputWithContext(ctx context.Context) Le }).(LeaseSpecPtrOutput) } +func (o LeaseSpecOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseSpec] { + return pulumix.Output[LeaseSpec]{ + OutputState: o.OutputState, + } +} + // acquireTime is a time when the current lease was acquired. func (o LeaseSpecOutput) AcquireTime() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseSpec) *string { return v.AcquireTime }).(pulumi.StringPtrOutput) @@ -461,6 +528,12 @@ func (o LeaseSpecPtrOutput) ToLeaseSpecPtrOutputWithContext(ctx context.Context) return o } +func (o LeaseSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpec] { + return pulumix.Output[*LeaseSpec]{ + OutputState: o.OutputState, + } +} + func (o LeaseSpecPtrOutput) Elem() LeaseSpecOutput { return o.ApplyT(func(v *LeaseSpec) LeaseSpec { if v != nil { @@ -572,6 +645,12 @@ func (i LeaseSpecPatchArgs) ToLeaseSpecPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecPatchOutput) } +func (i LeaseSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LeaseSpecPatch] { + return pulumix.Output[LeaseSpecPatch]{ + OutputState: i.ToLeaseSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i LeaseSpecPatchArgs) ToLeaseSpecPatchPtrOutput() LeaseSpecPatchPtrOutput { return i.ToLeaseSpecPatchPtrOutputWithContext(context.Background()) } @@ -613,6 +692,12 @@ func (i *leaseSpecPatchPtrType) ToLeaseSpecPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(LeaseSpecPatchPtrOutput) } +func (i *leaseSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpecPatch] { + return pulumix.Output[*LeaseSpecPatch]{ + OutputState: i.ToLeaseSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LeaseSpec is a specification of a Lease. type LeaseSpecPatchOutput struct{ *pulumi.OutputState } @@ -638,6 +723,12 @@ func (o LeaseSpecPatchOutput) ToLeaseSpecPatchPtrOutputWithContext(ctx context.C }).(LeaseSpecPatchPtrOutput) } +func (o LeaseSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LeaseSpecPatch] { + return pulumix.Output[LeaseSpecPatch]{ + OutputState: o.OutputState, + } +} + // acquireTime is a time when the current lease was acquired. func (o LeaseSpecPatchOutput) AcquireTime() pulumi.StringPtrOutput { return o.ApplyT(func(v LeaseSpecPatch) *string { return v.AcquireTime }).(pulumi.StringPtrOutput) @@ -677,6 +768,12 @@ func (o LeaseSpecPatchPtrOutput) ToLeaseSpecPatchPtrOutputWithContext(ctx contex return o } +func (o LeaseSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LeaseSpecPatch] { + return pulumix.Output[*LeaseSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o LeaseSpecPatchPtrOutput) Elem() LeaseSpecPatchOutput { return o.ApplyT(func(v *LeaseSpecPatch) LeaseSpecPatch { if v != nil { diff --git a/sdk/go/kubernetes/core/v1/binding.go b/sdk/go/kubernetes/core/v1/binding.go index 8256e977ad..16a5ebaca1 100644 --- a/sdk/go/kubernetes/core/v1/binding.go +++ b/sdk/go/kubernetes/core/v1/binding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Binding ties one object to another; for example, a pod is bound to a node by a scheduler. Deprecated in 1.7, please use the bindings subresource of pods instead. @@ -117,6 +118,12 @@ func (i *Binding) ToBindingOutputWithContext(ctx context.Context) BindingOutput return pulumi.ToOutputWithContext(ctx, i).(BindingOutput) } +func (i *Binding) ToOutput(ctx context.Context) pulumix.Output[*Binding] { + return pulumix.Output[*Binding]{ + OutputState: i.ToBindingOutputWithContext(ctx).OutputState, + } +} + // BindingArrayInput is an input type that accepts BindingArray and BindingArrayOutput values. // You can construct a concrete instance of `BindingArrayInput` via: // @@ -142,6 +149,12 @@ func (i BindingArray) ToBindingArrayOutputWithContext(ctx context.Context) Bindi return pulumi.ToOutputWithContext(ctx, i).(BindingArrayOutput) } +func (i BindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*Binding] { + return pulumix.Output[[]*Binding]{ + OutputState: i.ToBindingArrayOutputWithContext(ctx).OutputState, + } +} + // BindingMapInput is an input type that accepts BindingMap and BindingMapOutput values. // You can construct a concrete instance of `BindingMapInput` via: // @@ -167,6 +180,12 @@ func (i BindingMap) ToBindingMapOutputWithContext(ctx context.Context) BindingMa return pulumi.ToOutputWithContext(ctx, i).(BindingMapOutput) } +func (i BindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Binding] { + return pulumix.Output[map[string]*Binding]{ + OutputState: i.ToBindingMapOutputWithContext(ctx).OutputState, + } +} + type BindingOutput struct{ *pulumi.OutputState } func (BindingOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o BindingOutput) ToBindingOutputWithContext(ctx context.Context) BindingOu return o } +func (o BindingOutput) ToOutput(ctx context.Context) pulumix.Output[*Binding] { + return pulumix.Output[*Binding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o BindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Binding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o BindingArrayOutput) ToBindingArrayOutputWithContext(ctx context.Context) return o } +func (o BindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Binding] { + return pulumix.Output[[]*Binding]{ + OutputState: o.OutputState, + } +} + func (o BindingArrayOutput) Index(i pulumi.IntInput) BindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Binding { return vs[0].([]*Binding)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o BindingMapOutput) ToBindingMapOutputWithContext(ctx context.Context) Bin return o } +func (o BindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Binding] { + return pulumix.Output[map[string]*Binding]{ + OutputState: o.OutputState, + } +} + func (o BindingMapOutput) MapIndex(k pulumi.StringInput) BindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Binding { return vs[0].(map[string]*Binding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/bindingPatch.go b/sdk/go/kubernetes/core/v1/bindingPatch.go index 92a8209175..ea54d9c060 100644 --- a/sdk/go/kubernetes/core/v1/bindingPatch.go +++ b/sdk/go/kubernetes/core/v1/bindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -119,6 +120,12 @@ func (i *BindingPatch) ToBindingPatchOutputWithContext(ctx context.Context) Bind return pulumi.ToOutputWithContext(ctx, i).(BindingPatchOutput) } +func (i *BindingPatch) ToOutput(ctx context.Context) pulumix.Output[*BindingPatch] { + return pulumix.Output[*BindingPatch]{ + OutputState: i.ToBindingPatchOutputWithContext(ctx).OutputState, + } +} + // BindingPatchArrayInput is an input type that accepts BindingPatchArray and BindingPatchArrayOutput values. // You can construct a concrete instance of `BindingPatchArrayInput` via: // @@ -144,6 +151,12 @@ func (i BindingPatchArray) ToBindingPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(BindingPatchArrayOutput) } +func (i BindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*BindingPatch] { + return pulumix.Output[[]*BindingPatch]{ + OutputState: i.ToBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // BindingPatchMapInput is an input type that accepts BindingPatchMap and BindingPatchMapOutput values. // You can construct a concrete instance of `BindingPatchMapInput` via: // @@ -169,6 +182,12 @@ func (i BindingPatchMap) ToBindingPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(BindingPatchMapOutput) } +func (i BindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*BindingPatch] { + return pulumix.Output[map[string]*BindingPatch]{ + OutputState: i.ToBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type BindingPatchOutput struct{ *pulumi.OutputState } func (BindingPatchOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o BindingPatchOutput) ToBindingPatchOutputWithContext(ctx context.Context) return o } +func (o BindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*BindingPatch] { + return pulumix.Output[*BindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o BindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *BindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -217,6 +242,12 @@ func (o BindingPatchArrayOutput) ToBindingPatchArrayOutputWithContext(ctx contex return o } +func (o BindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*BindingPatch] { + return pulumix.Output[[]*BindingPatch]{ + OutputState: o.OutputState, + } +} + func (o BindingPatchArrayOutput) Index(i pulumi.IntInput) BindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *BindingPatch { return vs[0].([]*BindingPatch)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o BindingPatchMapOutput) ToBindingPatchMapOutputWithContext(ctx context.Co return o } +func (o BindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*BindingPatch] { + return pulumix.Output[map[string]*BindingPatch]{ + OutputState: o.OutputState, + } +} + func (o BindingPatchMapOutput) MapIndex(k pulumi.StringInput) BindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *BindingPatch { return vs[0].(map[string]*BindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/configMap.go b/sdk/go/kubernetes/core/v1/configMap.go index 473b65d0e4..77e020582c 100644 --- a/sdk/go/kubernetes/core/v1/configMap.go +++ b/sdk/go/kubernetes/core/v1/configMap.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ConfigMap holds configuration data for pods to consume. @@ -125,6 +126,12 @@ func (i *ConfigMap) ToConfigMapOutputWithContext(ctx context.Context) ConfigMapO return pulumi.ToOutputWithContext(ctx, i).(ConfigMapOutput) } +func (i *ConfigMap) ToOutput(ctx context.Context) pulumix.Output[*ConfigMap] { + return pulumix.Output[*ConfigMap]{ + OutputState: i.ToConfigMapOutputWithContext(ctx).OutputState, + } +} + // ConfigMapArrayInput is an input type that accepts ConfigMapArray and ConfigMapArrayOutput values. // You can construct a concrete instance of `ConfigMapArrayInput` via: // @@ -150,6 +157,12 @@ func (i ConfigMapArray) ToConfigMapArrayOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ConfigMapArrayOutput) } +func (i ConfigMapArray) ToOutput(ctx context.Context) pulumix.Output[[]*ConfigMap] { + return pulumix.Output[[]*ConfigMap]{ + OutputState: i.ToConfigMapArrayOutputWithContext(ctx).OutputState, + } +} + // ConfigMapMapInput is an input type that accepts ConfigMapMap and ConfigMapMapOutput values. // You can construct a concrete instance of `ConfigMapMapInput` via: // @@ -175,6 +188,12 @@ func (i ConfigMapMap) ToConfigMapMapOutputWithContext(ctx context.Context) Confi return pulumi.ToOutputWithContext(ctx, i).(ConfigMapMapOutput) } +func (i ConfigMapMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ConfigMap] { + return pulumix.Output[map[string]*ConfigMap]{ + OutputState: i.ToConfigMapMapOutputWithContext(ctx).OutputState, + } +} + type ConfigMapOutput struct{ *pulumi.OutputState } func (ConfigMapOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o ConfigMapOutput) ToConfigMapOutputWithContext(ctx context.Context) Confi return o } +func (o ConfigMapOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMap] { + return pulumix.Output[*ConfigMap]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ConfigMapOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ConfigMap) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -233,6 +258,12 @@ func (o ConfigMapArrayOutput) ToConfigMapArrayOutputWithContext(ctx context.Cont return o } +func (o ConfigMapArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ConfigMap] { + return pulumix.Output[[]*ConfigMap]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapArrayOutput) Index(i pulumi.IntInput) ConfigMapOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ConfigMap { return vs[0].([]*ConfigMap)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o ConfigMapMapOutput) ToConfigMapMapOutputWithContext(ctx context.Context) return o } +func (o ConfigMapMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ConfigMap] { + return pulumix.Output[map[string]*ConfigMap]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapMapOutput) MapIndex(k pulumi.StringInput) ConfigMapOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ConfigMap { return vs[0].(map[string]*ConfigMap)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/configMapList.go b/sdk/go/kubernetes/core/v1/configMapList.go index 56039f1424..36815da873 100644 --- a/sdk/go/kubernetes/core/v1/configMapList.go +++ b/sdk/go/kubernetes/core/v1/configMapList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ConfigMapList is a resource containing a list of ConfigMap objects. @@ -117,6 +118,12 @@ func (i *ConfigMapList) ToConfigMapListOutputWithContext(ctx context.Context) Co return pulumi.ToOutputWithContext(ctx, i).(ConfigMapListOutput) } +func (i *ConfigMapList) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapList] { + return pulumix.Output[*ConfigMapList]{ + OutputState: i.ToConfigMapListOutputWithContext(ctx).OutputState, + } +} + // ConfigMapListArrayInput is an input type that accepts ConfigMapListArray and ConfigMapListArrayOutput values. // You can construct a concrete instance of `ConfigMapListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ConfigMapListArray) ToConfigMapListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ConfigMapListArrayOutput) } +func (i ConfigMapListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ConfigMapList] { + return pulumix.Output[[]*ConfigMapList]{ + OutputState: i.ToConfigMapListArrayOutputWithContext(ctx).OutputState, + } +} + // ConfigMapListMapInput is an input type that accepts ConfigMapListMap and ConfigMapListMapOutput values. // You can construct a concrete instance of `ConfigMapListMapInput` via: // @@ -167,6 +180,12 @@ func (i ConfigMapListMap) ToConfigMapListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ConfigMapListMapOutput) } +func (i ConfigMapListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ConfigMapList] { + return pulumix.Output[map[string]*ConfigMapList]{ + OutputState: i.ToConfigMapListMapOutputWithContext(ctx).OutputState, + } +} + type ConfigMapListOutput struct{ *pulumi.OutputState } func (ConfigMapListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ConfigMapListOutput) ToConfigMapListOutputWithContext(ctx context.Contex return o } +func (o ConfigMapListOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapList] { + return pulumix.Output[*ConfigMapList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ConfigMapListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ConfigMapList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ConfigMapListArrayOutput) ToConfigMapListArrayOutputWithContext(ctx cont return o } +func (o ConfigMapListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ConfigMapList] { + return pulumix.Output[[]*ConfigMapList]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapListArrayOutput) Index(i pulumi.IntInput) ConfigMapListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ConfigMapList { return vs[0].([]*ConfigMapList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ConfigMapListMapOutput) ToConfigMapListMapOutputWithContext(ctx context. return o } +func (o ConfigMapListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ConfigMapList] { + return pulumix.Output[map[string]*ConfigMapList]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapListMapOutput) MapIndex(k pulumi.StringInput) ConfigMapListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ConfigMapList { return vs[0].(map[string]*ConfigMapList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/configMapPatch.go b/sdk/go/kubernetes/core/v1/configMapPatch.go index 76e5d5be80..2b469bd5ac 100644 --- a/sdk/go/kubernetes/core/v1/configMapPatch.go +++ b/sdk/go/kubernetes/core/v1/configMapPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -131,6 +132,12 @@ func (i *ConfigMapPatch) ToConfigMapPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ConfigMapPatchOutput) } +func (i *ConfigMapPatch) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapPatch] { + return pulumix.Output[*ConfigMapPatch]{ + OutputState: i.ToConfigMapPatchOutputWithContext(ctx).OutputState, + } +} + // ConfigMapPatchArrayInput is an input type that accepts ConfigMapPatchArray and ConfigMapPatchArrayOutput values. // You can construct a concrete instance of `ConfigMapPatchArrayInput` via: // @@ -156,6 +163,12 @@ func (i ConfigMapPatchArray) ToConfigMapPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ConfigMapPatchArrayOutput) } +func (i ConfigMapPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ConfigMapPatch] { + return pulumix.Output[[]*ConfigMapPatch]{ + OutputState: i.ToConfigMapPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ConfigMapPatchMapInput is an input type that accepts ConfigMapPatchMap and ConfigMapPatchMapOutput values. // You can construct a concrete instance of `ConfigMapPatchMapInput` via: // @@ -181,6 +194,12 @@ func (i ConfigMapPatchMap) ToConfigMapPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ConfigMapPatchMapOutput) } +func (i ConfigMapPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ConfigMapPatch] { + return pulumix.Output[map[string]*ConfigMapPatch]{ + OutputState: i.ToConfigMapPatchMapOutputWithContext(ctx).OutputState, + } +} + type ConfigMapPatchOutput struct{ *pulumi.OutputState } func (ConfigMapPatchOutput) ElementType() reflect.Type { @@ -195,6 +214,12 @@ func (o ConfigMapPatchOutput) ToConfigMapPatchOutputWithContext(ctx context.Cont return o } +func (o ConfigMapPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapPatch] { + return pulumix.Output[*ConfigMapPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ConfigMapPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ConfigMapPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -239,6 +264,12 @@ func (o ConfigMapPatchArrayOutput) ToConfigMapPatchArrayOutputWithContext(ctx co return o } +func (o ConfigMapPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ConfigMapPatch] { + return pulumix.Output[[]*ConfigMapPatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapPatchArrayOutput) Index(i pulumi.IntInput) ConfigMapPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ConfigMapPatch { return vs[0].([]*ConfigMapPatch)[vs[1].(int)] @@ -259,6 +290,12 @@ func (o ConfigMapPatchMapOutput) ToConfigMapPatchMapOutputWithContext(ctx contex return o } +func (o ConfigMapPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ConfigMapPatch] { + return pulumix.Output[map[string]*ConfigMapPatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapPatchMapOutput) MapIndex(k pulumi.StringInput) ConfigMapPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ConfigMapPatch { return vs[0].(map[string]*ConfigMapPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/endpoints.go b/sdk/go/kubernetes/core/v1/endpoints.go index e4cba4d99a..739191dd86 100644 --- a/sdk/go/kubernetes/core/v1/endpoints.go +++ b/sdk/go/kubernetes/core/v1/endpoints.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Endpoints is a collection of endpoints that implement the actual service. Example: @@ -125,6 +126,12 @@ func (i *Endpoints) ToEndpointsOutputWithContext(ctx context.Context) EndpointsO return pulumi.ToOutputWithContext(ctx, i).(EndpointsOutput) } +func (i *Endpoints) ToOutput(ctx context.Context) pulumix.Output[*Endpoints] { + return pulumix.Output[*Endpoints]{ + OutputState: i.ToEndpointsOutputWithContext(ctx).OutputState, + } +} + // EndpointsArrayInput is an input type that accepts EndpointsArray and EndpointsArrayOutput values. // You can construct a concrete instance of `EndpointsArrayInput` via: // @@ -150,6 +157,12 @@ func (i EndpointsArray) ToEndpointsArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EndpointsArrayOutput) } +func (i EndpointsArray) ToOutput(ctx context.Context) pulumix.Output[[]*Endpoints] { + return pulumix.Output[[]*Endpoints]{ + OutputState: i.ToEndpointsArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointsMapInput is an input type that accepts EndpointsMap and EndpointsMapOutput values. // You can construct a concrete instance of `EndpointsMapInput` via: // @@ -175,6 +188,12 @@ func (i EndpointsMap) ToEndpointsMapOutputWithContext(ctx context.Context) Endpo return pulumi.ToOutputWithContext(ctx, i).(EndpointsMapOutput) } +func (i EndpointsMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Endpoints] { + return pulumix.Output[map[string]*Endpoints]{ + OutputState: i.ToEndpointsMapOutputWithContext(ctx).OutputState, + } +} + type EndpointsOutput struct{ *pulumi.OutputState } func (EndpointsOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o EndpointsOutput) ToEndpointsOutputWithContext(ctx context.Context) Endpo return o } +func (o EndpointsOutput) ToOutput(ctx context.Context) pulumix.Output[*Endpoints] { + return pulumix.Output[*Endpoints]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointsOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Endpoints) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -223,6 +248,12 @@ func (o EndpointsArrayOutput) ToEndpointsArrayOutputWithContext(ctx context.Cont return o } +func (o EndpointsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Endpoints] { + return pulumix.Output[[]*Endpoints]{ + OutputState: o.OutputState, + } +} + func (o EndpointsArrayOutput) Index(i pulumi.IntInput) EndpointsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Endpoints { return vs[0].([]*Endpoints)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o EndpointsMapOutput) ToEndpointsMapOutputWithContext(ctx context.Context) return o } +func (o EndpointsMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Endpoints] { + return pulumix.Output[map[string]*Endpoints]{ + OutputState: o.OutputState, + } +} + func (o EndpointsMapOutput) MapIndex(k pulumi.StringInput) EndpointsOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Endpoints { return vs[0].(map[string]*Endpoints)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/endpointsList.go b/sdk/go/kubernetes/core/v1/endpointsList.go index c0b99abc5a..a4c4825d93 100644 --- a/sdk/go/kubernetes/core/v1/endpointsList.go +++ b/sdk/go/kubernetes/core/v1/endpointsList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EndpointsList is a list of endpoints. @@ -117,6 +118,12 @@ func (i *EndpointsList) ToEndpointsListOutputWithContext(ctx context.Context) En return pulumi.ToOutputWithContext(ctx, i).(EndpointsListOutput) } +func (i *EndpointsList) ToOutput(ctx context.Context) pulumix.Output[*EndpointsList] { + return pulumix.Output[*EndpointsList]{ + OutputState: i.ToEndpointsListOutputWithContext(ctx).OutputState, + } +} + // EndpointsListArrayInput is an input type that accepts EndpointsListArray and EndpointsListArrayOutput values. // You can construct a concrete instance of `EndpointsListArrayInput` via: // @@ -142,6 +149,12 @@ func (i EndpointsListArray) ToEndpointsListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EndpointsListArrayOutput) } +func (i EndpointsListArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointsList] { + return pulumix.Output[[]*EndpointsList]{ + OutputState: i.ToEndpointsListArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointsListMapInput is an input type that accepts EndpointsListMap and EndpointsListMapOutput values. // You can construct a concrete instance of `EndpointsListMapInput` via: // @@ -167,6 +180,12 @@ func (i EndpointsListMap) ToEndpointsListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EndpointsListMapOutput) } +func (i EndpointsListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointsList] { + return pulumix.Output[map[string]*EndpointsList]{ + OutputState: i.ToEndpointsListMapOutputWithContext(ctx).OutputState, + } +} + type EndpointsListOutput struct{ *pulumi.OutputState } func (EndpointsListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o EndpointsListOutput) ToEndpointsListOutputWithContext(ctx context.Contex return o } +func (o EndpointsListOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointsList] { + return pulumix.Output[*EndpointsList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointsListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *EndpointsList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o EndpointsListArrayOutput) ToEndpointsListArrayOutputWithContext(ctx cont return o } +func (o EndpointsListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointsList] { + return pulumix.Output[[]*EndpointsList]{ + OutputState: o.OutputState, + } +} + func (o EndpointsListArrayOutput) Index(i pulumi.IntInput) EndpointsListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointsList { return vs[0].([]*EndpointsList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o EndpointsListMapOutput) ToEndpointsListMapOutputWithContext(ctx context. return o } +func (o EndpointsListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointsList] { + return pulumix.Output[map[string]*EndpointsList]{ + OutputState: o.OutputState, + } +} + func (o EndpointsListMapOutput) MapIndex(k pulumi.StringInput) EndpointsListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointsList { return vs[0].(map[string]*EndpointsList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/endpointsPatch.go b/sdk/go/kubernetes/core/v1/endpointsPatch.go index e94c254ab2..aeb89b8491 100644 --- a/sdk/go/kubernetes/core/v1/endpointsPatch.go +++ b/sdk/go/kubernetes/core/v1/endpointsPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -131,6 +132,12 @@ func (i *EndpointsPatch) ToEndpointsPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EndpointsPatchOutput) } +func (i *EndpointsPatch) ToOutput(ctx context.Context) pulumix.Output[*EndpointsPatch] { + return pulumix.Output[*EndpointsPatch]{ + OutputState: i.ToEndpointsPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointsPatchArrayInput is an input type that accepts EndpointsPatchArray and EndpointsPatchArrayOutput values. // You can construct a concrete instance of `EndpointsPatchArrayInput` via: // @@ -156,6 +163,12 @@ func (i EndpointsPatchArray) ToEndpointsPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointsPatchArrayOutput) } +func (i EndpointsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointsPatch] { + return pulumix.Output[[]*EndpointsPatch]{ + OutputState: i.ToEndpointsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointsPatchMapInput is an input type that accepts EndpointsPatchMap and EndpointsPatchMapOutput values. // You can construct a concrete instance of `EndpointsPatchMapInput` via: // @@ -181,6 +194,12 @@ func (i EndpointsPatchMap) ToEndpointsPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(EndpointsPatchMapOutput) } +func (i EndpointsPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointsPatch] { + return pulumix.Output[map[string]*EndpointsPatch]{ + OutputState: i.ToEndpointsPatchMapOutputWithContext(ctx).OutputState, + } +} + type EndpointsPatchOutput struct{ *pulumi.OutputState } func (EndpointsPatchOutput) ElementType() reflect.Type { @@ -195,6 +214,12 @@ func (o EndpointsPatchOutput) ToEndpointsPatchOutputWithContext(ctx context.Cont return o } +func (o EndpointsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointsPatch] { + return pulumix.Output[*EndpointsPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointsPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *EndpointsPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -229,6 +254,12 @@ func (o EndpointsPatchArrayOutput) ToEndpointsPatchArrayOutputWithContext(ctx co return o } +func (o EndpointsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointsPatch] { + return pulumix.Output[[]*EndpointsPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointsPatchArrayOutput) Index(i pulumi.IntInput) EndpointsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointsPatch { return vs[0].([]*EndpointsPatch)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o EndpointsPatchMapOutput) ToEndpointsPatchMapOutputWithContext(ctx contex return o } +func (o EndpointsPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointsPatch] { + return pulumix.Output[map[string]*EndpointsPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointsPatchMapOutput) MapIndex(k pulumi.StringInput) EndpointsPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointsPatch { return vs[0].(map[string]*EndpointsPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/event.go b/sdk/go/kubernetes/core/v1/event.go index 2b16fd5f3d..200a8ca4f7 100644 --- a/sdk/go/kubernetes/core/v1/event.go +++ b/sdk/go/kubernetes/core/v1/event.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. @@ -207,6 +208,12 @@ func (i *Event) ToEventOutputWithContext(ctx context.Context) EventOutput { return pulumi.ToOutputWithContext(ctx, i).(EventOutput) } +func (i *Event) ToOutput(ctx context.Context) pulumix.Output[*Event] { + return pulumix.Output[*Event]{ + OutputState: i.ToEventOutputWithContext(ctx).OutputState, + } +} + // EventArrayInput is an input type that accepts EventArray and EventArrayOutput values. // You can construct a concrete instance of `EventArrayInput` via: // @@ -232,6 +239,12 @@ func (i EventArray) ToEventArrayOutputWithContext(ctx context.Context) EventArra return pulumi.ToOutputWithContext(ctx, i).(EventArrayOutput) } +func (i EventArray) ToOutput(ctx context.Context) pulumix.Output[[]*Event] { + return pulumix.Output[[]*Event]{ + OutputState: i.ToEventArrayOutputWithContext(ctx).OutputState, + } +} + // EventMapInput is an input type that accepts EventMap and EventMapOutput values. // You can construct a concrete instance of `EventMapInput` via: // @@ -257,6 +270,12 @@ func (i EventMap) ToEventMapOutputWithContext(ctx context.Context) EventMapOutpu return pulumi.ToOutputWithContext(ctx, i).(EventMapOutput) } +func (i EventMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Event] { + return pulumix.Output[map[string]*Event]{ + OutputState: i.ToEventMapOutputWithContext(ctx).OutputState, + } +} + type EventOutput struct{ *pulumi.OutputState } func (EventOutput) ElementType() reflect.Type { @@ -271,6 +290,12 @@ func (o EventOutput) ToEventOutputWithContext(ctx context.Context) EventOutput { return o } +func (o EventOutput) ToOutput(ctx context.Context) pulumix.Output[*Event] { + return pulumix.Output[*Event]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the Regarding object. func (o EventOutput) Action() pulumi.StringOutput { return o.ApplyT(func(v *Event) pulumi.StringOutput { return v.Action }).(pulumi.StringOutput) @@ -370,6 +395,12 @@ func (o EventArrayOutput) ToEventArrayOutputWithContext(ctx context.Context) Eve return o } +func (o EventArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Event] { + return pulumix.Output[[]*Event]{ + OutputState: o.OutputState, + } +} + func (o EventArrayOutput) Index(i pulumi.IntInput) EventOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Event { return vs[0].([]*Event)[vs[1].(int)] @@ -390,6 +421,12 @@ func (o EventMapOutput) ToEventMapOutputWithContext(ctx context.Context) EventMa return o } +func (o EventMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Event] { + return pulumix.Output[map[string]*Event]{ + OutputState: o.OutputState, + } +} + func (o EventMapOutput) MapIndex(k pulumi.StringInput) EventOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Event { return vs[0].(map[string]*Event)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/eventList.go b/sdk/go/kubernetes/core/v1/eventList.go index ee229d2356..98fd65a5a0 100644 --- a/sdk/go/kubernetes/core/v1/eventList.go +++ b/sdk/go/kubernetes/core/v1/eventList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EventList is a list of events. @@ -117,6 +118,12 @@ func (i *EventList) ToEventListOutputWithContext(ctx context.Context) EventListO return pulumi.ToOutputWithContext(ctx, i).(EventListOutput) } +func (i *EventList) ToOutput(ctx context.Context) pulumix.Output[*EventList] { + return pulumix.Output[*EventList]{ + OutputState: i.ToEventListOutputWithContext(ctx).OutputState, + } +} + // EventListArrayInput is an input type that accepts EventListArray and EventListArrayOutput values. // You can construct a concrete instance of `EventListArrayInput` via: // @@ -142,6 +149,12 @@ func (i EventListArray) ToEventListArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EventListArrayOutput) } +func (i EventListArray) ToOutput(ctx context.Context) pulumix.Output[[]*EventList] { + return pulumix.Output[[]*EventList]{ + OutputState: i.ToEventListArrayOutputWithContext(ctx).OutputState, + } +} + // EventListMapInput is an input type that accepts EventListMap and EventListMapOutput values. // You can construct a concrete instance of `EventListMapInput` via: // @@ -167,6 +180,12 @@ func (i EventListMap) ToEventListMapOutputWithContext(ctx context.Context) Event return pulumi.ToOutputWithContext(ctx, i).(EventListMapOutput) } +func (i EventListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventList] { + return pulumix.Output[map[string]*EventList]{ + OutputState: i.ToEventListMapOutputWithContext(ctx).OutputState, + } +} + type EventListOutput struct{ *pulumi.OutputState } func (EventListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o EventListOutput) ToEventListOutputWithContext(ctx context.Context) Event return o } +func (o EventListOutput) ToOutput(ctx context.Context) pulumix.Output[*EventList] { + return pulumix.Output[*EventList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EventListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *EventList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o EventListArrayOutput) ToEventListArrayOutputWithContext(ctx context.Cont return o } +func (o EventListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EventList] { + return pulumix.Output[[]*EventList]{ + OutputState: o.OutputState, + } +} + func (o EventListArrayOutput) Index(i pulumi.IntInput) EventListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventList { return vs[0].([]*EventList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o EventListMapOutput) ToEventListMapOutputWithContext(ctx context.Context) return o } +func (o EventListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventList] { + return pulumix.Output[map[string]*EventList]{ + OutputState: o.OutputState, + } +} + func (o EventListMapOutput) MapIndex(k pulumi.StringInput) EventListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EventList { return vs[0].(map[string]*EventList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/eventPatch.go b/sdk/go/kubernetes/core/v1/eventPatch.go index 01a2bd7374..5f2ef12637 100644 --- a/sdk/go/kubernetes/core/v1/eventPatch.go +++ b/sdk/go/kubernetes/core/v1/eventPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -206,6 +207,12 @@ func (i *EventPatch) ToEventPatchOutputWithContext(ctx context.Context) EventPat return pulumi.ToOutputWithContext(ctx, i).(EventPatchOutput) } +func (i *EventPatch) ToOutput(ctx context.Context) pulumix.Output[*EventPatch] { + return pulumix.Output[*EventPatch]{ + OutputState: i.ToEventPatchOutputWithContext(ctx).OutputState, + } +} + // EventPatchArrayInput is an input type that accepts EventPatchArray and EventPatchArrayOutput values. // You can construct a concrete instance of `EventPatchArrayInput` via: // @@ -231,6 +238,12 @@ func (i EventPatchArray) ToEventPatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EventPatchArrayOutput) } +func (i EventPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*EventPatch] { + return pulumix.Output[[]*EventPatch]{ + OutputState: i.ToEventPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EventPatchMapInput is an input type that accepts EventPatchMap and EventPatchMapOutput values. // You can construct a concrete instance of `EventPatchMapInput` via: // @@ -256,6 +269,12 @@ func (i EventPatchMap) ToEventPatchMapOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventPatchMapOutput) } +func (i EventPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventPatch] { + return pulumix.Output[map[string]*EventPatch]{ + OutputState: i.ToEventPatchMapOutputWithContext(ctx).OutputState, + } +} + type EventPatchOutput struct{ *pulumi.OutputState } func (EventPatchOutput) ElementType() reflect.Type { @@ -270,6 +289,12 @@ func (o EventPatchOutput) ToEventPatchOutputWithContext(ctx context.Context) Eve return o } +func (o EventPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*EventPatch] { + return pulumix.Output[*EventPatch]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the Regarding object. func (o EventPatchOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v *EventPatch) pulumi.StringPtrOutput { return v.Action }).(pulumi.StringPtrOutput) @@ -369,6 +394,12 @@ func (o EventPatchArrayOutput) ToEventPatchArrayOutputWithContext(ctx context.Co return o } +func (o EventPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EventPatch] { + return pulumix.Output[[]*EventPatch]{ + OutputState: o.OutputState, + } +} + func (o EventPatchArrayOutput) Index(i pulumi.IntInput) EventPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventPatch { return vs[0].([]*EventPatch)[vs[1].(int)] @@ -389,6 +420,12 @@ func (o EventPatchMapOutput) ToEventPatchMapOutputWithContext(ctx context.Contex return o } +func (o EventPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventPatch] { + return pulumix.Output[map[string]*EventPatch]{ + OutputState: o.OutputState, + } +} + func (o EventPatchMapOutput) MapIndex(k pulumi.StringInput) EventPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EventPatch { return vs[0].(map[string]*EventPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/limitRange.go b/sdk/go/kubernetes/core/v1/limitRange.go index 8afd6d3a05..0c2354cac3 100644 --- a/sdk/go/kubernetes/core/v1/limitRange.go +++ b/sdk/go/kubernetes/core/v1/limitRange.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // LimitRange sets resource usage limits for each kind of resource in a Namespace. @@ -113,6 +114,12 @@ func (i *LimitRange) ToLimitRangeOutputWithContext(ctx context.Context) LimitRan return pulumi.ToOutputWithContext(ctx, i).(LimitRangeOutput) } +func (i *LimitRange) ToOutput(ctx context.Context) pulumix.Output[*LimitRange] { + return pulumix.Output[*LimitRange]{ + OutputState: i.ToLimitRangeOutputWithContext(ctx).OutputState, + } +} + // LimitRangeArrayInput is an input type that accepts LimitRangeArray and LimitRangeArrayOutput values. // You can construct a concrete instance of `LimitRangeArrayInput` via: // @@ -138,6 +145,12 @@ func (i LimitRangeArray) ToLimitRangeArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LimitRangeArrayOutput) } +func (i LimitRangeArray) ToOutput(ctx context.Context) pulumix.Output[[]*LimitRange] { + return pulumix.Output[[]*LimitRange]{ + OutputState: i.ToLimitRangeArrayOutputWithContext(ctx).OutputState, + } +} + // LimitRangeMapInput is an input type that accepts LimitRangeMap and LimitRangeMapOutput values. // You can construct a concrete instance of `LimitRangeMapInput` via: // @@ -163,6 +176,12 @@ func (i LimitRangeMap) ToLimitRangeMapOutputWithContext(ctx context.Context) Lim return pulumi.ToOutputWithContext(ctx, i).(LimitRangeMapOutput) } +func (i LimitRangeMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LimitRange] { + return pulumix.Output[map[string]*LimitRange]{ + OutputState: i.ToLimitRangeMapOutputWithContext(ctx).OutputState, + } +} + type LimitRangeOutput struct{ *pulumi.OutputState } func (LimitRangeOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o LimitRangeOutput) ToLimitRangeOutputWithContext(ctx context.Context) Lim return o } +func (o LimitRangeOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitRange] { + return pulumix.Output[*LimitRange]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LimitRangeOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *LimitRange) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o LimitRangeArrayOutput) ToLimitRangeArrayOutputWithContext(ctx context.Co return o } +func (o LimitRangeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LimitRange] { + return pulumix.Output[[]*LimitRange]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeArrayOutput) Index(i pulumi.IntInput) LimitRangeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LimitRange { return vs[0].([]*LimitRange)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o LimitRangeMapOutput) ToLimitRangeMapOutputWithContext(ctx context.Contex return o } +func (o LimitRangeMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LimitRange] { + return pulumix.Output[map[string]*LimitRange]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeMapOutput) MapIndex(k pulumi.StringInput) LimitRangeOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LimitRange { return vs[0].(map[string]*LimitRange)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/limitRangeList.go b/sdk/go/kubernetes/core/v1/limitRangeList.go index 55cc282c86..b8e08a74e3 100644 --- a/sdk/go/kubernetes/core/v1/limitRangeList.go +++ b/sdk/go/kubernetes/core/v1/limitRangeList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // LimitRangeList is a list of LimitRange items. @@ -117,6 +118,12 @@ func (i *LimitRangeList) ToLimitRangeListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LimitRangeListOutput) } +func (i *LimitRangeList) ToOutput(ctx context.Context) pulumix.Output[*LimitRangeList] { + return pulumix.Output[*LimitRangeList]{ + OutputState: i.ToLimitRangeListOutputWithContext(ctx).OutputState, + } +} + // LimitRangeListArrayInput is an input type that accepts LimitRangeListArray and LimitRangeListArrayOutput values. // You can construct a concrete instance of `LimitRangeListArrayInput` via: // @@ -142,6 +149,12 @@ func (i LimitRangeListArray) ToLimitRangeListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(LimitRangeListArrayOutput) } +func (i LimitRangeListArray) ToOutput(ctx context.Context) pulumix.Output[[]*LimitRangeList] { + return pulumix.Output[[]*LimitRangeList]{ + OutputState: i.ToLimitRangeListArrayOutputWithContext(ctx).OutputState, + } +} + // LimitRangeListMapInput is an input type that accepts LimitRangeListMap and LimitRangeListMapOutput values. // You can construct a concrete instance of `LimitRangeListMapInput` via: // @@ -167,6 +180,12 @@ func (i LimitRangeListMap) ToLimitRangeListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(LimitRangeListMapOutput) } +func (i LimitRangeListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LimitRangeList] { + return pulumix.Output[map[string]*LimitRangeList]{ + OutputState: i.ToLimitRangeListMapOutputWithContext(ctx).OutputState, + } +} + type LimitRangeListOutput struct{ *pulumi.OutputState } func (LimitRangeListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o LimitRangeListOutput) ToLimitRangeListOutputWithContext(ctx context.Cont return o } +func (o LimitRangeListOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitRangeList] { + return pulumix.Output[*LimitRangeList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LimitRangeListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *LimitRangeList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o LimitRangeListArrayOutput) ToLimitRangeListArrayOutputWithContext(ctx co return o } +func (o LimitRangeListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LimitRangeList] { + return pulumix.Output[[]*LimitRangeList]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeListArrayOutput) Index(i pulumi.IntInput) LimitRangeListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LimitRangeList { return vs[0].([]*LimitRangeList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o LimitRangeListMapOutput) ToLimitRangeListMapOutputWithContext(ctx contex return o } +func (o LimitRangeListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LimitRangeList] { + return pulumix.Output[map[string]*LimitRangeList]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeListMapOutput) MapIndex(k pulumi.StringInput) LimitRangeListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LimitRangeList { return vs[0].(map[string]*LimitRangeList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/limitRangePatch.go b/sdk/go/kubernetes/core/v1/limitRangePatch.go index a4aa3b6182..59dc15ed62 100644 --- a/sdk/go/kubernetes/core/v1/limitRangePatch.go +++ b/sdk/go/kubernetes/core/v1/limitRangePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -119,6 +120,12 @@ func (i *LimitRangePatch) ToLimitRangePatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(LimitRangePatchOutput) } +func (i *LimitRangePatch) ToOutput(ctx context.Context) pulumix.Output[*LimitRangePatch] { + return pulumix.Output[*LimitRangePatch]{ + OutputState: i.ToLimitRangePatchOutputWithContext(ctx).OutputState, + } +} + // LimitRangePatchArrayInput is an input type that accepts LimitRangePatchArray and LimitRangePatchArrayOutput values. // You can construct a concrete instance of `LimitRangePatchArrayInput` via: // @@ -144,6 +151,12 @@ func (i LimitRangePatchArray) ToLimitRangePatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LimitRangePatchArrayOutput) } +func (i LimitRangePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*LimitRangePatch] { + return pulumix.Output[[]*LimitRangePatch]{ + OutputState: i.ToLimitRangePatchArrayOutputWithContext(ctx).OutputState, + } +} + // LimitRangePatchMapInput is an input type that accepts LimitRangePatchMap and LimitRangePatchMapOutput values. // You can construct a concrete instance of `LimitRangePatchMapInput` via: // @@ -169,6 +182,12 @@ func (i LimitRangePatchMap) ToLimitRangePatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(LimitRangePatchMapOutput) } +func (i LimitRangePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*LimitRangePatch] { + return pulumix.Output[map[string]*LimitRangePatch]{ + OutputState: i.ToLimitRangePatchMapOutputWithContext(ctx).OutputState, + } +} + type LimitRangePatchOutput struct{ *pulumi.OutputState } func (LimitRangePatchOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o LimitRangePatchOutput) ToLimitRangePatchOutputWithContext(ctx context.Co return o } +func (o LimitRangePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitRangePatch] { + return pulumix.Output[*LimitRangePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LimitRangePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *LimitRangePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -217,6 +242,12 @@ func (o LimitRangePatchArrayOutput) ToLimitRangePatchArrayOutputWithContext(ctx return o } +func (o LimitRangePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*LimitRangePatch] { + return pulumix.Output[[]*LimitRangePatch]{ + OutputState: o.OutputState, + } +} + func (o LimitRangePatchArrayOutput) Index(i pulumi.IntInput) LimitRangePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LimitRangePatch { return vs[0].([]*LimitRangePatch)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o LimitRangePatchMapOutput) ToLimitRangePatchMapOutputWithContext(ctx cont return o } +func (o LimitRangePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*LimitRangePatch] { + return pulumix.Output[map[string]*LimitRangePatch]{ + OutputState: o.OutputState, + } +} + func (o LimitRangePatchMapOutput) MapIndex(k pulumi.StringInput) LimitRangePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LimitRangePatch { return vs[0].(map[string]*LimitRangePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/namespace.go b/sdk/go/kubernetes/core/v1/namespace.go index 391534e7b3..364840305a 100644 --- a/sdk/go/kubernetes/core/v1/namespace.go +++ b/sdk/go/kubernetes/core/v1/namespace.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Namespace provides a scope for Names. Use of multiple namespaces is optional. @@ -115,6 +116,12 @@ func (i *Namespace) ToNamespaceOutputWithContext(ctx context.Context) NamespaceO return pulumi.ToOutputWithContext(ctx, i).(NamespaceOutput) } +func (i *Namespace) ToOutput(ctx context.Context) pulumix.Output[*Namespace] { + return pulumix.Output[*Namespace]{ + OutputState: i.ToNamespaceOutputWithContext(ctx).OutputState, + } +} + // NamespaceArrayInput is an input type that accepts NamespaceArray and NamespaceArrayOutput values. // You can construct a concrete instance of `NamespaceArrayInput` via: // @@ -140,6 +147,12 @@ func (i NamespaceArray) ToNamespaceArrayOutputWithContext(ctx context.Context) N return pulumi.ToOutputWithContext(ctx, i).(NamespaceArrayOutput) } +func (i NamespaceArray) ToOutput(ctx context.Context) pulumix.Output[[]*Namespace] { + return pulumix.Output[[]*Namespace]{ + OutputState: i.ToNamespaceArrayOutputWithContext(ctx).OutputState, + } +} + // NamespaceMapInput is an input type that accepts NamespaceMap and NamespaceMapOutput values. // You can construct a concrete instance of `NamespaceMapInput` via: // @@ -165,6 +178,12 @@ func (i NamespaceMap) ToNamespaceMapOutputWithContext(ctx context.Context) Names return pulumi.ToOutputWithContext(ctx, i).(NamespaceMapOutput) } +func (i NamespaceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Namespace] { + return pulumix.Output[map[string]*Namespace]{ + OutputState: i.ToNamespaceMapOutputWithContext(ctx).OutputState, + } +} + type NamespaceOutput struct{ *pulumi.OutputState } func (NamespaceOutput) ElementType() reflect.Type { @@ -179,6 +198,12 @@ func (o NamespaceOutput) ToNamespaceOutputWithContext(ctx context.Context) Names return o } +func (o NamespaceOutput) ToOutput(ctx context.Context) pulumix.Output[*Namespace] { + return pulumix.Output[*Namespace]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NamespaceOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Namespace) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -218,6 +243,12 @@ func (o NamespaceArrayOutput) ToNamespaceArrayOutputWithContext(ctx context.Cont return o } +func (o NamespaceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Namespace] { + return pulumix.Output[[]*Namespace]{ + OutputState: o.OutputState, + } +} + func (o NamespaceArrayOutput) Index(i pulumi.IntInput) NamespaceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Namespace { return vs[0].([]*Namespace)[vs[1].(int)] @@ -238,6 +269,12 @@ func (o NamespaceMapOutput) ToNamespaceMapOutputWithContext(ctx context.Context) return o } +func (o NamespaceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Namespace] { + return pulumix.Output[map[string]*Namespace]{ + OutputState: o.OutputState, + } +} + func (o NamespaceMapOutput) MapIndex(k pulumi.StringInput) NamespaceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Namespace { return vs[0].(map[string]*Namespace)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/namespaceList.go b/sdk/go/kubernetes/core/v1/namespaceList.go index 41038d8246..2259375f73 100644 --- a/sdk/go/kubernetes/core/v1/namespaceList.go +++ b/sdk/go/kubernetes/core/v1/namespaceList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // NamespaceList is a list of Namespaces. @@ -117,6 +118,12 @@ func (i *NamespaceList) ToNamespaceListOutputWithContext(ctx context.Context) Na return pulumi.ToOutputWithContext(ctx, i).(NamespaceListOutput) } +func (i *NamespaceList) ToOutput(ctx context.Context) pulumix.Output[*NamespaceList] { + return pulumix.Output[*NamespaceList]{ + OutputState: i.ToNamespaceListOutputWithContext(ctx).OutputState, + } +} + // NamespaceListArrayInput is an input type that accepts NamespaceListArray and NamespaceListArrayOutput values. // You can construct a concrete instance of `NamespaceListArrayInput` via: // @@ -142,6 +149,12 @@ func (i NamespaceListArray) ToNamespaceListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NamespaceListArrayOutput) } +func (i NamespaceListArray) ToOutput(ctx context.Context) pulumix.Output[[]*NamespaceList] { + return pulumix.Output[[]*NamespaceList]{ + OutputState: i.ToNamespaceListArrayOutputWithContext(ctx).OutputState, + } +} + // NamespaceListMapInput is an input type that accepts NamespaceListMap and NamespaceListMapOutput values. // You can construct a concrete instance of `NamespaceListMapInput` via: // @@ -167,6 +180,12 @@ func (i NamespaceListMap) ToNamespaceListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(NamespaceListMapOutput) } +func (i NamespaceListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamespaceList] { + return pulumix.Output[map[string]*NamespaceList]{ + OutputState: i.ToNamespaceListMapOutputWithContext(ctx).OutputState, + } +} + type NamespaceListOutput struct{ *pulumi.OutputState } func (NamespaceListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o NamespaceListOutput) ToNamespaceListOutputWithContext(ctx context.Contex return o } +func (o NamespaceListOutput) ToOutput(ctx context.Context) pulumix.Output[*NamespaceList] { + return pulumix.Output[*NamespaceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NamespaceListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *NamespaceList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o NamespaceListArrayOutput) ToNamespaceListArrayOutputWithContext(ctx cont return o } +func (o NamespaceListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NamespaceList] { + return pulumix.Output[[]*NamespaceList]{ + OutputState: o.OutputState, + } +} + func (o NamespaceListArrayOutput) Index(i pulumi.IntInput) NamespaceListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NamespaceList { return vs[0].([]*NamespaceList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o NamespaceListMapOutput) ToNamespaceListMapOutputWithContext(ctx context. return o } +func (o NamespaceListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamespaceList] { + return pulumix.Output[map[string]*NamespaceList]{ + OutputState: o.OutputState, + } +} + func (o NamespaceListMapOutput) MapIndex(k pulumi.StringInput) NamespaceListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NamespaceList { return vs[0].(map[string]*NamespaceList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/namespacePatch.go b/sdk/go/kubernetes/core/v1/namespacePatch.go index ba11390ad6..e25ad2f348 100644 --- a/sdk/go/kubernetes/core/v1/namespacePatch.go +++ b/sdk/go/kubernetes/core/v1/namespacePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -121,6 +122,12 @@ func (i *NamespacePatch) ToNamespacePatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(NamespacePatchOutput) } +func (i *NamespacePatch) ToOutput(ctx context.Context) pulumix.Output[*NamespacePatch] { + return pulumix.Output[*NamespacePatch]{ + OutputState: i.ToNamespacePatchOutputWithContext(ctx).OutputState, + } +} + // NamespacePatchArrayInput is an input type that accepts NamespacePatchArray and NamespacePatchArrayOutput values. // You can construct a concrete instance of `NamespacePatchArrayInput` via: // @@ -146,6 +153,12 @@ func (i NamespacePatchArray) ToNamespacePatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NamespacePatchArrayOutput) } +func (i NamespacePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*NamespacePatch] { + return pulumix.Output[[]*NamespacePatch]{ + OutputState: i.ToNamespacePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NamespacePatchMapInput is an input type that accepts NamespacePatchMap and NamespacePatchMapOutput values. // You can construct a concrete instance of `NamespacePatchMapInput` via: // @@ -171,6 +184,12 @@ func (i NamespacePatchMap) ToNamespacePatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(NamespacePatchMapOutput) } +func (i NamespacePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamespacePatch] { + return pulumix.Output[map[string]*NamespacePatch]{ + OutputState: i.ToNamespacePatchMapOutputWithContext(ctx).OutputState, + } +} + type NamespacePatchOutput struct{ *pulumi.OutputState } func (NamespacePatchOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o NamespacePatchOutput) ToNamespacePatchOutputWithContext(ctx context.Cont return o } +func (o NamespacePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*NamespacePatch] { + return pulumix.Output[*NamespacePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NamespacePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *NamespacePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -224,6 +249,12 @@ func (o NamespacePatchArrayOutput) ToNamespacePatchArrayOutputWithContext(ctx co return o } +func (o NamespacePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NamespacePatch] { + return pulumix.Output[[]*NamespacePatch]{ + OutputState: o.OutputState, + } +} + func (o NamespacePatchArrayOutput) Index(i pulumi.IntInput) NamespacePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NamespacePatch { return vs[0].([]*NamespacePatch)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o NamespacePatchMapOutput) ToNamespacePatchMapOutputWithContext(ctx contex return o } +func (o NamespacePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamespacePatch] { + return pulumix.Output[map[string]*NamespacePatch]{ + OutputState: o.OutputState, + } +} + func (o NamespacePatchMapOutput) MapIndex(k pulumi.StringInput) NamespacePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NamespacePatch { return vs[0].(map[string]*NamespacePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/node.go b/sdk/go/kubernetes/core/v1/node.go index 1b18788fa8..63fe3866e0 100644 --- a/sdk/go/kubernetes/core/v1/node.go +++ b/sdk/go/kubernetes/core/v1/node.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd). @@ -115,6 +116,12 @@ func (i *Node) ToNodeOutputWithContext(ctx context.Context) NodeOutput { return pulumi.ToOutputWithContext(ctx, i).(NodeOutput) } +func (i *Node) ToOutput(ctx context.Context) pulumix.Output[*Node] { + return pulumix.Output[*Node]{ + OutputState: i.ToNodeOutputWithContext(ctx).OutputState, + } +} + // NodeArrayInput is an input type that accepts NodeArray and NodeArrayOutput values. // You can construct a concrete instance of `NodeArrayInput` via: // @@ -140,6 +147,12 @@ func (i NodeArray) ToNodeArrayOutputWithContext(ctx context.Context) NodeArrayOu return pulumi.ToOutputWithContext(ctx, i).(NodeArrayOutput) } +func (i NodeArray) ToOutput(ctx context.Context) pulumix.Output[[]*Node] { + return pulumix.Output[[]*Node]{ + OutputState: i.ToNodeArrayOutputWithContext(ctx).OutputState, + } +} + // NodeMapInput is an input type that accepts NodeMap and NodeMapOutput values. // You can construct a concrete instance of `NodeMapInput` via: // @@ -165,6 +178,12 @@ func (i NodeMap) ToNodeMapOutputWithContext(ctx context.Context) NodeMapOutput { return pulumi.ToOutputWithContext(ctx, i).(NodeMapOutput) } +func (i NodeMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Node] { + return pulumix.Output[map[string]*Node]{ + OutputState: i.ToNodeMapOutputWithContext(ctx).OutputState, + } +} + type NodeOutput struct{ *pulumi.OutputState } func (NodeOutput) ElementType() reflect.Type { @@ -179,6 +198,12 @@ func (o NodeOutput) ToNodeOutputWithContext(ctx context.Context) NodeOutput { return o } +func (o NodeOutput) ToOutput(ctx context.Context) pulumix.Output[*Node] { + return pulumix.Output[*Node]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NodeOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Node) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -218,6 +243,12 @@ func (o NodeArrayOutput) ToNodeArrayOutputWithContext(ctx context.Context) NodeA return o } +func (o NodeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Node] { + return pulumix.Output[[]*Node]{ + OutputState: o.OutputState, + } +} + func (o NodeArrayOutput) Index(i pulumi.IntInput) NodeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Node { return vs[0].([]*Node)[vs[1].(int)] @@ -238,6 +269,12 @@ func (o NodeMapOutput) ToNodeMapOutputWithContext(ctx context.Context) NodeMapOu return o } +func (o NodeMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Node] { + return pulumix.Output[map[string]*Node]{ + OutputState: o.OutputState, + } +} + func (o NodeMapOutput) MapIndex(k pulumi.StringInput) NodeOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Node { return vs[0].(map[string]*Node)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/nodeList.go b/sdk/go/kubernetes/core/v1/nodeList.go index 09db28a039..dfc0bc8a03 100644 --- a/sdk/go/kubernetes/core/v1/nodeList.go +++ b/sdk/go/kubernetes/core/v1/nodeList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // NodeList is the whole list of all Nodes which have been registered with master. @@ -117,6 +118,12 @@ func (i *NodeList) ToNodeListOutputWithContext(ctx context.Context) NodeListOutp return pulumi.ToOutputWithContext(ctx, i).(NodeListOutput) } +func (i *NodeList) ToOutput(ctx context.Context) pulumix.Output[*NodeList] { + return pulumix.Output[*NodeList]{ + OutputState: i.ToNodeListOutputWithContext(ctx).OutputState, + } +} + // NodeListArrayInput is an input type that accepts NodeListArray and NodeListArrayOutput values. // You can construct a concrete instance of `NodeListArrayInput` via: // @@ -142,6 +149,12 @@ func (i NodeListArray) ToNodeListArrayOutputWithContext(ctx context.Context) Nod return pulumi.ToOutputWithContext(ctx, i).(NodeListArrayOutput) } +func (i NodeListArray) ToOutput(ctx context.Context) pulumix.Output[[]*NodeList] { + return pulumix.Output[[]*NodeList]{ + OutputState: i.ToNodeListArrayOutputWithContext(ctx).OutputState, + } +} + // NodeListMapInput is an input type that accepts NodeListMap and NodeListMapOutput values. // You can construct a concrete instance of `NodeListMapInput` via: // @@ -167,6 +180,12 @@ func (i NodeListMap) ToNodeListMapOutputWithContext(ctx context.Context) NodeLis return pulumi.ToOutputWithContext(ctx, i).(NodeListMapOutput) } +func (i NodeListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NodeList] { + return pulumix.Output[map[string]*NodeList]{ + OutputState: i.ToNodeListMapOutputWithContext(ctx).OutputState, + } +} + type NodeListOutput struct{ *pulumi.OutputState } func (NodeListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o NodeListOutput) ToNodeListOutputWithContext(ctx context.Context) NodeLis return o } +func (o NodeListOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeList] { + return pulumix.Output[*NodeList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NodeListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *NodeList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o NodeListArrayOutput) ToNodeListArrayOutputWithContext(ctx context.Contex return o } +func (o NodeListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NodeList] { + return pulumix.Output[[]*NodeList]{ + OutputState: o.OutputState, + } +} + func (o NodeListArrayOutput) Index(i pulumi.IntInput) NodeListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NodeList { return vs[0].([]*NodeList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o NodeListMapOutput) ToNodeListMapOutputWithContext(ctx context.Context) N return o } +func (o NodeListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NodeList] { + return pulumix.Output[map[string]*NodeList]{ + OutputState: o.OutputState, + } +} + func (o NodeListMapOutput) MapIndex(k pulumi.StringInput) NodeListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NodeList { return vs[0].(map[string]*NodeList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/nodePatch.go b/sdk/go/kubernetes/core/v1/nodePatch.go index b7c151f9fa..90c683a3ce 100644 --- a/sdk/go/kubernetes/core/v1/nodePatch.go +++ b/sdk/go/kubernetes/core/v1/nodePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -121,6 +122,12 @@ func (i *NodePatch) ToNodePatchOutputWithContext(ctx context.Context) NodePatchO return pulumi.ToOutputWithContext(ctx, i).(NodePatchOutput) } +func (i *NodePatch) ToOutput(ctx context.Context) pulumix.Output[*NodePatch] { + return pulumix.Output[*NodePatch]{ + OutputState: i.ToNodePatchOutputWithContext(ctx).OutputState, + } +} + // NodePatchArrayInput is an input type that accepts NodePatchArray and NodePatchArrayOutput values. // You can construct a concrete instance of `NodePatchArrayInput` via: // @@ -146,6 +153,12 @@ func (i NodePatchArray) ToNodePatchArrayOutputWithContext(ctx context.Context) N return pulumi.ToOutputWithContext(ctx, i).(NodePatchArrayOutput) } +func (i NodePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*NodePatch] { + return pulumix.Output[[]*NodePatch]{ + OutputState: i.ToNodePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NodePatchMapInput is an input type that accepts NodePatchMap and NodePatchMapOutput values. // You can construct a concrete instance of `NodePatchMapInput` via: // @@ -171,6 +184,12 @@ func (i NodePatchMap) ToNodePatchMapOutputWithContext(ctx context.Context) NodeP return pulumi.ToOutputWithContext(ctx, i).(NodePatchMapOutput) } +func (i NodePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NodePatch] { + return pulumix.Output[map[string]*NodePatch]{ + OutputState: i.ToNodePatchMapOutputWithContext(ctx).OutputState, + } +} + type NodePatchOutput struct{ *pulumi.OutputState } func (NodePatchOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o NodePatchOutput) ToNodePatchOutputWithContext(ctx context.Context) NodeP return o } +func (o NodePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*NodePatch] { + return pulumix.Output[*NodePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NodePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *NodePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -224,6 +249,12 @@ func (o NodePatchArrayOutput) ToNodePatchArrayOutputWithContext(ctx context.Cont return o } +func (o NodePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NodePatch] { + return pulumix.Output[[]*NodePatch]{ + OutputState: o.OutputState, + } +} + func (o NodePatchArrayOutput) Index(i pulumi.IntInput) NodePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NodePatch { return vs[0].([]*NodePatch)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o NodePatchMapOutput) ToNodePatchMapOutputWithContext(ctx context.Context) return o } +func (o NodePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NodePatch] { + return pulumix.Output[map[string]*NodePatch]{ + OutputState: o.OutputState, + } +} + func (o NodePatchMapOutput) MapIndex(k pulumi.StringInput) NodePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NodePatch { return vs[0].(map[string]*NodePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/persistentVolume.go b/sdk/go/kubernetes/core/v1/persistentVolume.go index 7731e0dd67..f0975b6fa6 100644 --- a/sdk/go/kubernetes/core/v1/persistentVolume.go +++ b/sdk/go/kubernetes/core/v1/persistentVolume.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes @@ -115,6 +116,12 @@ func (i *PersistentVolume) ToPersistentVolumeOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeOutput) } +func (i *PersistentVolume) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolume] { + return pulumix.Output[*PersistentVolume]{ + OutputState: i.ToPersistentVolumeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeArrayInput is an input type that accepts PersistentVolumeArray and PersistentVolumeArrayOutput values. // You can construct a concrete instance of `PersistentVolumeArrayInput` via: // @@ -140,6 +147,12 @@ func (i PersistentVolumeArray) ToPersistentVolumeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeArrayOutput) } +func (i PersistentVolumeArray) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolume] { + return pulumix.Output[[]*PersistentVolume]{ + OutputState: i.ToPersistentVolumeArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeMapInput is an input type that accepts PersistentVolumeMap and PersistentVolumeMapOutput values. // You can construct a concrete instance of `PersistentVolumeMapInput` via: // @@ -165,6 +178,12 @@ func (i PersistentVolumeMap) ToPersistentVolumeMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeMapOutput) } +func (i PersistentVolumeMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolume] { + return pulumix.Output[map[string]*PersistentVolume]{ + OutputState: i.ToPersistentVolumeMapOutputWithContext(ctx).OutputState, + } +} + type PersistentVolumeOutput struct{ *pulumi.OutputState } func (PersistentVolumeOutput) ElementType() reflect.Type { @@ -179,6 +198,12 @@ func (o PersistentVolumeOutput) ToPersistentVolumeOutputWithContext(ctx context. return o } +func (o PersistentVolumeOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolume] { + return pulumix.Output[*PersistentVolume]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PersistentVolume) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -218,6 +243,12 @@ func (o PersistentVolumeArrayOutput) ToPersistentVolumeArrayOutputWithContext(ct return o } +func (o PersistentVolumeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolume] { + return pulumix.Output[[]*PersistentVolume]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeArrayOutput) Index(i pulumi.IntInput) PersistentVolumeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PersistentVolume { return vs[0].([]*PersistentVolume)[vs[1].(int)] @@ -238,6 +269,12 @@ func (o PersistentVolumeMapOutput) ToPersistentVolumeMapOutputWithContext(ctx co return o } +func (o PersistentVolumeMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolume] { + return pulumix.Output[map[string]*PersistentVolume]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeMapOutput) MapIndex(k pulumi.StringInput) PersistentVolumeOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PersistentVolume { return vs[0].(map[string]*PersistentVolume)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/persistentVolumeClaim.go b/sdk/go/kubernetes/core/v1/persistentVolumeClaim.go index 3fcf21ce2d..daeea6df6b 100644 --- a/sdk/go/kubernetes/core/v1/persistentVolumeClaim.go +++ b/sdk/go/kubernetes/core/v1/persistentVolumeClaim.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PersistentVolumeClaim is a user's request for and claim to a persistent volume @@ -115,6 +116,12 @@ func (i *PersistentVolumeClaim) ToPersistentVolumeClaimOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimOutput) } +func (i *PersistentVolumeClaim) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaim] { + return pulumix.Output[*PersistentVolumeClaim]{ + OutputState: i.ToPersistentVolumeClaimOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimArrayInput is an input type that accepts PersistentVolumeClaimArray and PersistentVolumeClaimArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimArrayInput` via: // @@ -140,6 +147,12 @@ func (i PersistentVolumeClaimArray) ToPersistentVolumeClaimArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimArrayOutput) } +func (i PersistentVolumeClaimArray) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeClaim] { + return pulumix.Output[[]*PersistentVolumeClaim]{ + OutputState: i.ToPersistentVolumeClaimArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimMapInput is an input type that accepts PersistentVolumeClaimMap and PersistentVolumeClaimMapOutput values. // You can construct a concrete instance of `PersistentVolumeClaimMapInput` via: // @@ -165,6 +178,12 @@ func (i PersistentVolumeClaimMap) ToPersistentVolumeClaimMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimMapOutput) } +func (i PersistentVolumeClaimMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeClaim] { + return pulumix.Output[map[string]*PersistentVolumeClaim]{ + OutputState: i.ToPersistentVolumeClaimMapOutputWithContext(ctx).OutputState, + } +} + type PersistentVolumeClaimOutput struct{ *pulumi.OutputState } func (PersistentVolumeClaimOutput) ElementType() reflect.Type { @@ -179,6 +198,12 @@ func (o PersistentVolumeClaimOutput) ToPersistentVolumeClaimOutputWithContext(ct return o } +func (o PersistentVolumeClaimOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaim] { + return pulumix.Output[*PersistentVolumeClaim]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeClaimOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PersistentVolumeClaim) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -218,6 +243,12 @@ func (o PersistentVolumeClaimArrayOutput) ToPersistentVolumeClaimArrayOutputWith return o } +func (o PersistentVolumeClaimArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeClaim] { + return pulumix.Output[[]*PersistentVolumeClaim]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PersistentVolumeClaim { return vs[0].([]*PersistentVolumeClaim)[vs[1].(int)] @@ -238,6 +269,12 @@ func (o PersistentVolumeClaimMapOutput) ToPersistentVolumeClaimMapOutputWithCont return o } +func (o PersistentVolumeClaimMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeClaim] { + return pulumix.Output[map[string]*PersistentVolumeClaim]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimMapOutput) MapIndex(k pulumi.StringInput) PersistentVolumeClaimOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PersistentVolumeClaim { return vs[0].(map[string]*PersistentVolumeClaim)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/persistentVolumeClaimList.go b/sdk/go/kubernetes/core/v1/persistentVolumeClaimList.go index ac14b70d7b..b13de2b621 100644 --- a/sdk/go/kubernetes/core/v1/persistentVolumeClaimList.go +++ b/sdk/go/kubernetes/core/v1/persistentVolumeClaimList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PersistentVolumeClaimList is a list of PersistentVolumeClaim items. @@ -117,6 +118,12 @@ func (i *PersistentVolumeClaimList) ToPersistentVolumeClaimListOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimListOutput) } +func (i *PersistentVolumeClaimList) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimList] { + return pulumix.Output[*PersistentVolumeClaimList]{ + OutputState: i.ToPersistentVolumeClaimListOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimListArrayInput is an input type that accepts PersistentVolumeClaimListArray and PersistentVolumeClaimListArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PersistentVolumeClaimListArray) ToPersistentVolumeClaimListArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimListArrayOutput) } +func (i PersistentVolumeClaimListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeClaimList] { + return pulumix.Output[[]*PersistentVolumeClaimList]{ + OutputState: i.ToPersistentVolumeClaimListArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimListMapInput is an input type that accepts PersistentVolumeClaimListMap and PersistentVolumeClaimListMapOutput values. // You can construct a concrete instance of `PersistentVolumeClaimListMapInput` via: // @@ -167,6 +180,12 @@ func (i PersistentVolumeClaimListMap) ToPersistentVolumeClaimListMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimListMapOutput) } +func (i PersistentVolumeClaimListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeClaimList] { + return pulumix.Output[map[string]*PersistentVolumeClaimList]{ + OutputState: i.ToPersistentVolumeClaimListMapOutputWithContext(ctx).OutputState, + } +} + type PersistentVolumeClaimListOutput struct{ *pulumi.OutputState } func (PersistentVolumeClaimListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PersistentVolumeClaimListOutput) ToPersistentVolumeClaimListOutputWithCo return o } +func (o PersistentVolumeClaimListOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimList] { + return pulumix.Output[*PersistentVolumeClaimList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeClaimListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PersistentVolumeClaimList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PersistentVolumeClaimListArrayOutput) ToPersistentVolumeClaimListArrayOu return o } +func (o PersistentVolumeClaimListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeClaimList] { + return pulumix.Output[[]*PersistentVolumeClaimList]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimListArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PersistentVolumeClaimList { return vs[0].([]*PersistentVolumeClaimList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PersistentVolumeClaimListMapOutput) ToPersistentVolumeClaimListMapOutput return o } +func (o PersistentVolumeClaimListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeClaimList] { + return pulumix.Output[map[string]*PersistentVolumeClaimList]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimListMapOutput) MapIndex(k pulumi.StringInput) PersistentVolumeClaimListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PersistentVolumeClaimList { return vs[0].(map[string]*PersistentVolumeClaimList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/persistentVolumeClaimPatch.go b/sdk/go/kubernetes/core/v1/persistentVolumeClaimPatch.go index e356d52da4..6f854827e9 100644 --- a/sdk/go/kubernetes/core/v1/persistentVolumeClaimPatch.go +++ b/sdk/go/kubernetes/core/v1/persistentVolumeClaimPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -121,6 +122,12 @@ func (i *PersistentVolumeClaimPatch) ToPersistentVolumeClaimPatchOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimPatchOutput) } +func (i *PersistentVolumeClaimPatch) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimPatch] { + return pulumix.Output[*PersistentVolumeClaimPatch]{ + OutputState: i.ToPersistentVolumeClaimPatchOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimPatchArrayInput is an input type that accepts PersistentVolumeClaimPatchArray and PersistentVolumeClaimPatchArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimPatchArrayInput` via: // @@ -146,6 +153,12 @@ func (i PersistentVolumeClaimPatchArray) ToPersistentVolumeClaimPatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimPatchArrayOutput) } +func (i PersistentVolumeClaimPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeClaimPatch] { + return pulumix.Output[[]*PersistentVolumeClaimPatch]{ + OutputState: i.ToPersistentVolumeClaimPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimPatchMapInput is an input type that accepts PersistentVolumeClaimPatchMap and PersistentVolumeClaimPatchMapOutput values. // You can construct a concrete instance of `PersistentVolumeClaimPatchMapInput` via: // @@ -171,6 +184,12 @@ func (i PersistentVolumeClaimPatchMap) ToPersistentVolumeClaimPatchMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimPatchMapOutput) } +func (i PersistentVolumeClaimPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeClaimPatch] { + return pulumix.Output[map[string]*PersistentVolumeClaimPatch]{ + OutputState: i.ToPersistentVolumeClaimPatchMapOutputWithContext(ctx).OutputState, + } +} + type PersistentVolumeClaimPatchOutput struct{ *pulumi.OutputState } func (PersistentVolumeClaimPatchOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o PersistentVolumeClaimPatchOutput) ToPersistentVolumeClaimPatchOutputWith return o } +func (o PersistentVolumeClaimPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimPatch] { + return pulumix.Output[*PersistentVolumeClaimPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeClaimPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PersistentVolumeClaimPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -224,6 +249,12 @@ func (o PersistentVolumeClaimPatchArrayOutput) ToPersistentVolumeClaimPatchArray return o } +func (o PersistentVolumeClaimPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeClaimPatch] { + return pulumix.Output[[]*PersistentVolumeClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimPatchArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PersistentVolumeClaimPatch { return vs[0].([]*PersistentVolumeClaimPatch)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o PersistentVolumeClaimPatchMapOutput) ToPersistentVolumeClaimPatchMapOutp return o } +func (o PersistentVolumeClaimPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeClaimPatch] { + return pulumix.Output[map[string]*PersistentVolumeClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimPatchMapOutput) MapIndex(k pulumi.StringInput) PersistentVolumeClaimPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PersistentVolumeClaimPatch { return vs[0].(map[string]*PersistentVolumeClaimPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/persistentVolumeList.go b/sdk/go/kubernetes/core/v1/persistentVolumeList.go index 2c0ce0503b..ac4e2693c0 100644 --- a/sdk/go/kubernetes/core/v1/persistentVolumeList.go +++ b/sdk/go/kubernetes/core/v1/persistentVolumeList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PersistentVolumeList is a list of PersistentVolume items. @@ -117,6 +118,12 @@ func (i *PersistentVolumeList) ToPersistentVolumeListOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeListOutput) } +func (i *PersistentVolumeList) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeList] { + return pulumix.Output[*PersistentVolumeList]{ + OutputState: i.ToPersistentVolumeListOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeListArrayInput is an input type that accepts PersistentVolumeListArray and PersistentVolumeListArrayOutput values. // You can construct a concrete instance of `PersistentVolumeListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PersistentVolumeListArray) ToPersistentVolumeListArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeListArrayOutput) } +func (i PersistentVolumeListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeList] { + return pulumix.Output[[]*PersistentVolumeList]{ + OutputState: i.ToPersistentVolumeListArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeListMapInput is an input type that accepts PersistentVolumeListMap and PersistentVolumeListMapOutput values. // You can construct a concrete instance of `PersistentVolumeListMapInput` via: // @@ -167,6 +180,12 @@ func (i PersistentVolumeListMap) ToPersistentVolumeListMapOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeListMapOutput) } +func (i PersistentVolumeListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeList] { + return pulumix.Output[map[string]*PersistentVolumeList]{ + OutputState: i.ToPersistentVolumeListMapOutputWithContext(ctx).OutputState, + } +} + type PersistentVolumeListOutput struct{ *pulumi.OutputState } func (PersistentVolumeListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PersistentVolumeListOutput) ToPersistentVolumeListOutputWithContext(ctx return o } +func (o PersistentVolumeListOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeList] { + return pulumix.Output[*PersistentVolumeList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PersistentVolumeList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PersistentVolumeListArrayOutput) ToPersistentVolumeListArrayOutputWithCo return o } +func (o PersistentVolumeListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumeList] { + return pulumix.Output[[]*PersistentVolumeList]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeListArrayOutput) Index(i pulumi.IntInput) PersistentVolumeListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PersistentVolumeList { return vs[0].([]*PersistentVolumeList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PersistentVolumeListMapOutput) ToPersistentVolumeListMapOutputWithContex return o } +func (o PersistentVolumeListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumeList] { + return pulumix.Output[map[string]*PersistentVolumeList]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeListMapOutput) MapIndex(k pulumi.StringInput) PersistentVolumeListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PersistentVolumeList { return vs[0].(map[string]*PersistentVolumeList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/persistentVolumePatch.go b/sdk/go/kubernetes/core/v1/persistentVolumePatch.go index 0170aa6fe6..d86d6031af 100644 --- a/sdk/go/kubernetes/core/v1/persistentVolumePatch.go +++ b/sdk/go/kubernetes/core/v1/persistentVolumePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -121,6 +122,12 @@ func (i *PersistentVolumePatch) ToPersistentVolumePatchOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumePatchOutput) } +func (i *PersistentVolumePatch) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumePatch] { + return pulumix.Output[*PersistentVolumePatch]{ + OutputState: i.ToPersistentVolumePatchOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumePatchArrayInput is an input type that accepts PersistentVolumePatchArray and PersistentVolumePatchArrayOutput values. // You can construct a concrete instance of `PersistentVolumePatchArrayInput` via: // @@ -146,6 +153,12 @@ func (i PersistentVolumePatchArray) ToPersistentVolumePatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumePatchArrayOutput) } +func (i PersistentVolumePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumePatch] { + return pulumix.Output[[]*PersistentVolumePatch]{ + OutputState: i.ToPersistentVolumePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumePatchMapInput is an input type that accepts PersistentVolumePatchMap and PersistentVolumePatchMapOutput values. // You can construct a concrete instance of `PersistentVolumePatchMapInput` via: // @@ -171,6 +184,12 @@ func (i PersistentVolumePatchMap) ToPersistentVolumePatchMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumePatchMapOutput) } +func (i PersistentVolumePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumePatch] { + return pulumix.Output[map[string]*PersistentVolumePatch]{ + OutputState: i.ToPersistentVolumePatchMapOutputWithContext(ctx).OutputState, + } +} + type PersistentVolumePatchOutput struct{ *pulumi.OutputState } func (PersistentVolumePatchOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o PersistentVolumePatchOutput) ToPersistentVolumePatchOutputWithContext(ct return o } +func (o PersistentVolumePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumePatch] { + return pulumix.Output[*PersistentVolumePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PersistentVolumePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -224,6 +249,12 @@ func (o PersistentVolumePatchArrayOutput) ToPersistentVolumePatchArrayOutputWith return o } +func (o PersistentVolumePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PersistentVolumePatch] { + return pulumix.Output[[]*PersistentVolumePatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumePatchArrayOutput) Index(i pulumi.IntInput) PersistentVolumePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PersistentVolumePatch { return vs[0].([]*PersistentVolumePatch)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o PersistentVolumePatchMapOutput) ToPersistentVolumePatchMapOutputWithCont return o } +func (o PersistentVolumePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PersistentVolumePatch] { + return pulumix.Output[map[string]*PersistentVolumePatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumePatchMapOutput) MapIndex(k pulumi.StringInput) PersistentVolumePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PersistentVolumePatch { return vs[0].(map[string]*PersistentVolumePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/pod.go b/sdk/go/kubernetes/core/v1/pod.go index 6e1c64e66f..d0f1bf896b 100644 --- a/sdk/go/kubernetes/core/v1/pod.go +++ b/sdk/go/kubernetes/core/v1/pod.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts. @@ -208,6 +209,12 @@ func (i *Pod) ToPodOutputWithContext(ctx context.Context) PodOutput { return pulumi.ToOutputWithContext(ctx, i).(PodOutput) } +func (i *Pod) ToOutput(ctx context.Context) pulumix.Output[*Pod] { + return pulumix.Output[*Pod]{ + OutputState: i.ToPodOutputWithContext(ctx).OutputState, + } +} + // PodArrayInput is an input type that accepts PodArray and PodArrayOutput values. // You can construct a concrete instance of `PodArrayInput` via: // @@ -233,6 +240,12 @@ func (i PodArray) ToPodArrayOutputWithContext(ctx context.Context) PodArrayOutpu return pulumi.ToOutputWithContext(ctx, i).(PodArrayOutput) } +func (i PodArray) ToOutput(ctx context.Context) pulumix.Output[[]*Pod] { + return pulumix.Output[[]*Pod]{ + OutputState: i.ToPodArrayOutputWithContext(ctx).OutputState, + } +} + // PodMapInput is an input type that accepts PodMap and PodMapOutput values. // You can construct a concrete instance of `PodMapInput` via: // @@ -258,6 +271,12 @@ func (i PodMap) ToPodMapOutputWithContext(ctx context.Context) PodMapOutput { return pulumi.ToOutputWithContext(ctx, i).(PodMapOutput) } +func (i PodMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Pod] { + return pulumix.Output[map[string]*Pod]{ + OutputState: i.ToPodMapOutputWithContext(ctx).OutputState, + } +} + type PodOutput struct{ *pulumi.OutputState } func (PodOutput) ElementType() reflect.Type { @@ -272,6 +291,12 @@ func (o PodOutput) ToPodOutputWithContext(ctx context.Context) PodOutput { return o } +func (o PodOutput) ToOutput(ctx context.Context) pulumix.Output[*Pod] { + return pulumix.Output[*Pod]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Pod) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -311,6 +336,12 @@ func (o PodArrayOutput) ToPodArrayOutputWithContext(ctx context.Context) PodArra return o } +func (o PodArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Pod] { + return pulumix.Output[[]*Pod]{ + OutputState: o.OutputState, + } +} + func (o PodArrayOutput) Index(i pulumi.IntInput) PodOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Pod { return vs[0].([]*Pod)[vs[1].(int)] @@ -331,6 +362,12 @@ func (o PodMapOutput) ToPodMapOutputWithContext(ctx context.Context) PodMapOutpu return o } +func (o PodMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Pod] { + return pulumix.Output[map[string]*Pod]{ + OutputState: o.OutputState, + } +} + func (o PodMapOutput) MapIndex(k pulumi.StringInput) PodOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Pod { return vs[0].(map[string]*Pod)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/podList.go b/sdk/go/kubernetes/core/v1/podList.go index 457c19faaa..bb2f470ddd 100644 --- a/sdk/go/kubernetes/core/v1/podList.go +++ b/sdk/go/kubernetes/core/v1/podList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodList is a list of Pods. @@ -117,6 +118,12 @@ func (i *PodList) ToPodListOutputWithContext(ctx context.Context) PodListOutput return pulumi.ToOutputWithContext(ctx, i).(PodListOutput) } +func (i *PodList) ToOutput(ctx context.Context) pulumix.Output[*PodList] { + return pulumix.Output[*PodList]{ + OutputState: i.ToPodListOutputWithContext(ctx).OutputState, + } +} + // PodListArrayInput is an input type that accepts PodListArray and PodListArrayOutput values. // You can construct a concrete instance of `PodListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodListArray) ToPodListArrayOutputWithContext(ctx context.Context) PodLi return pulumi.ToOutputWithContext(ctx, i).(PodListArrayOutput) } +func (i PodListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodList] { + return pulumix.Output[[]*PodList]{ + OutputState: i.ToPodListArrayOutputWithContext(ctx).OutputState, + } +} + // PodListMapInput is an input type that accepts PodListMap and PodListMapOutput values. // You can construct a concrete instance of `PodListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodListMap) ToPodListMapOutputWithContext(ctx context.Context) PodListMa return pulumi.ToOutputWithContext(ctx, i).(PodListMapOutput) } +func (i PodListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodList] { + return pulumix.Output[map[string]*PodList]{ + OutputState: i.ToPodListMapOutputWithContext(ctx).OutputState, + } +} + type PodListOutput struct{ *pulumi.OutputState } func (PodListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodListOutput) ToPodListOutputWithContext(ctx context.Context) PodListOu return o } +func (o PodListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodList] { + return pulumix.Output[*PodList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodListArrayOutput) ToPodListArrayOutputWithContext(ctx context.Context) return o } +func (o PodListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodList] { + return pulumix.Output[[]*PodList]{ + OutputState: o.OutputState, + } +} + func (o PodListArrayOutput) Index(i pulumi.IntInput) PodListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodList { return vs[0].([]*PodList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodListMapOutput) ToPodListMapOutputWithContext(ctx context.Context) Pod return o } +func (o PodListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodList] { + return pulumix.Output[map[string]*PodList]{ + OutputState: o.OutputState, + } +} + func (o PodListMapOutput) MapIndex(k pulumi.StringInput) PodListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodList { return vs[0].(map[string]*PodList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/podPatch.go b/sdk/go/kubernetes/core/v1/podPatch.go index 9d7171676c..8d310ef229 100644 --- a/sdk/go/kubernetes/core/v1/podPatch.go +++ b/sdk/go/kubernetes/core/v1/podPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -136,6 +137,12 @@ func (i *PodPatch) ToPodPatchOutputWithContext(ctx context.Context) PodPatchOutp return pulumi.ToOutputWithContext(ctx, i).(PodPatchOutput) } +func (i *PodPatch) ToOutput(ctx context.Context) pulumix.Output[*PodPatch] { + return pulumix.Output[*PodPatch]{ + OutputState: i.ToPodPatchOutputWithContext(ctx).OutputState, + } +} + // PodPatchArrayInput is an input type that accepts PodPatchArray and PodPatchArrayOutput values. // You can construct a concrete instance of `PodPatchArrayInput` via: // @@ -161,6 +168,12 @@ func (i PodPatchArray) ToPodPatchArrayOutputWithContext(ctx context.Context) Pod return pulumi.ToOutputWithContext(ctx, i).(PodPatchArrayOutput) } +func (i PodPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodPatch] { + return pulumix.Output[[]*PodPatch]{ + OutputState: i.ToPodPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodPatchMapInput is an input type that accepts PodPatchMap and PodPatchMapOutput values. // You can construct a concrete instance of `PodPatchMapInput` via: // @@ -186,6 +199,12 @@ func (i PodPatchMap) ToPodPatchMapOutputWithContext(ctx context.Context) PodPatc return pulumi.ToOutputWithContext(ctx, i).(PodPatchMapOutput) } +func (i PodPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPatch] { + return pulumix.Output[map[string]*PodPatch]{ + OutputState: i.ToPodPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodPatchOutput struct{ *pulumi.OutputState } func (PodPatchOutput) ElementType() reflect.Type { @@ -200,6 +219,12 @@ func (o PodPatchOutput) ToPodPatchOutputWithContext(ctx context.Context) PodPatc return o } +func (o PodPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodPatch] { + return pulumix.Output[*PodPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -239,6 +264,12 @@ func (o PodPatchArrayOutput) ToPodPatchArrayOutputWithContext(ctx context.Contex return o } +func (o PodPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodPatch] { + return pulumix.Output[[]*PodPatch]{ + OutputState: o.OutputState, + } +} + func (o PodPatchArrayOutput) Index(i pulumi.IntInput) PodPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodPatch { return vs[0].([]*PodPatch)[vs[1].(int)] @@ -259,6 +290,12 @@ func (o PodPatchMapOutput) ToPodPatchMapOutputWithContext(ctx context.Context) P return o } +func (o PodPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPatch] { + return pulumix.Output[map[string]*PodPatch]{ + OutputState: o.OutputState, + } +} + func (o PodPatchMapOutput) MapIndex(k pulumi.StringInput) PodPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodPatch { return vs[0].(map[string]*PodPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/podTemplate.go b/sdk/go/kubernetes/core/v1/podTemplate.go index aa71828cbf..e90972b682 100644 --- a/sdk/go/kubernetes/core/v1/podTemplate.go +++ b/sdk/go/kubernetes/core/v1/podTemplate.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodTemplate describes a template for creating copies of a predefined pod. @@ -113,6 +114,12 @@ func (i *PodTemplate) ToPodTemplateOutputWithContext(ctx context.Context) PodTem return pulumi.ToOutputWithContext(ctx, i).(PodTemplateOutput) } +func (i *PodTemplate) ToOutput(ctx context.Context) pulumix.Output[*PodTemplate] { + return pulumix.Output[*PodTemplate]{ + OutputState: i.ToPodTemplateOutputWithContext(ctx).OutputState, + } +} + // PodTemplateArrayInput is an input type that accepts PodTemplateArray and PodTemplateArrayOutput values. // You can construct a concrete instance of `PodTemplateArrayInput` via: // @@ -138,6 +145,12 @@ func (i PodTemplateArray) ToPodTemplateArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PodTemplateArrayOutput) } +func (i PodTemplateArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodTemplate] { + return pulumix.Output[[]*PodTemplate]{ + OutputState: i.ToPodTemplateArrayOutputWithContext(ctx).OutputState, + } +} + // PodTemplateMapInput is an input type that accepts PodTemplateMap and PodTemplateMapOutput values. // You can construct a concrete instance of `PodTemplateMapInput` via: // @@ -163,6 +176,12 @@ func (i PodTemplateMap) ToPodTemplateMapOutputWithContext(ctx context.Context) P return pulumi.ToOutputWithContext(ctx, i).(PodTemplateMapOutput) } +func (i PodTemplateMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodTemplate] { + return pulumix.Output[map[string]*PodTemplate]{ + OutputState: i.ToPodTemplateMapOutputWithContext(ctx).OutputState, + } +} + type PodTemplateOutput struct{ *pulumi.OutputState } func (PodTemplateOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o PodTemplateOutput) ToPodTemplateOutputWithContext(ctx context.Context) P return o } +func (o PodTemplateOutput) ToOutput(ctx context.Context) pulumix.Output[*PodTemplate] { + return pulumix.Output[*PodTemplate]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTemplateOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodTemplate) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o PodTemplateArrayOutput) ToPodTemplateArrayOutputWithContext(ctx context. return o } +func (o PodTemplateArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodTemplate] { + return pulumix.Output[[]*PodTemplate]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateArrayOutput) Index(i pulumi.IntInput) PodTemplateOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodTemplate { return vs[0].([]*PodTemplate)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o PodTemplateMapOutput) ToPodTemplateMapOutputWithContext(ctx context.Cont return o } +func (o PodTemplateMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodTemplate] { + return pulumix.Output[map[string]*PodTemplate]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateMapOutput) MapIndex(k pulumi.StringInput) PodTemplateOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodTemplate { return vs[0].(map[string]*PodTemplate)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/podTemplateList.go b/sdk/go/kubernetes/core/v1/podTemplateList.go index f1bfc3c39c..9fbefa3b84 100644 --- a/sdk/go/kubernetes/core/v1/podTemplateList.go +++ b/sdk/go/kubernetes/core/v1/podTemplateList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodTemplateList is a list of PodTemplates. @@ -117,6 +118,12 @@ func (i *PodTemplateList) ToPodTemplateListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(PodTemplateListOutput) } +func (i *PodTemplateList) ToOutput(ctx context.Context) pulumix.Output[*PodTemplateList] { + return pulumix.Output[*PodTemplateList]{ + OutputState: i.ToPodTemplateListOutputWithContext(ctx).OutputState, + } +} + // PodTemplateListArrayInput is an input type that accepts PodTemplateListArray and PodTemplateListArrayOutput values. // You can construct a concrete instance of `PodTemplateListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodTemplateListArray) ToPodTemplateListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodTemplateListArrayOutput) } +func (i PodTemplateListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodTemplateList] { + return pulumix.Output[[]*PodTemplateList]{ + OutputState: i.ToPodTemplateListArrayOutputWithContext(ctx).OutputState, + } +} + // PodTemplateListMapInput is an input type that accepts PodTemplateListMap and PodTemplateListMapOutput values. // You can construct a concrete instance of `PodTemplateListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodTemplateListMap) ToPodTemplateListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodTemplateListMapOutput) } +func (i PodTemplateListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodTemplateList] { + return pulumix.Output[map[string]*PodTemplateList]{ + OutputState: i.ToPodTemplateListMapOutputWithContext(ctx).OutputState, + } +} + type PodTemplateListOutput struct{ *pulumi.OutputState } func (PodTemplateListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodTemplateListOutput) ToPodTemplateListOutputWithContext(ctx context.Co return o } +func (o PodTemplateListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodTemplateList] { + return pulumix.Output[*PodTemplateList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTemplateListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodTemplateList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodTemplateListArrayOutput) ToPodTemplateListArrayOutputWithContext(ctx return o } +func (o PodTemplateListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodTemplateList] { + return pulumix.Output[[]*PodTemplateList]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateListArrayOutput) Index(i pulumi.IntInput) PodTemplateListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodTemplateList { return vs[0].([]*PodTemplateList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodTemplateListMapOutput) ToPodTemplateListMapOutputWithContext(ctx cont return o } +func (o PodTemplateListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodTemplateList] { + return pulumix.Output[map[string]*PodTemplateList]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateListMapOutput) MapIndex(k pulumi.StringInput) PodTemplateListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodTemplateList { return vs[0].(map[string]*PodTemplateList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/podTemplatePatch.go b/sdk/go/kubernetes/core/v1/podTemplatePatch.go index 8228d60dc4..2d8e947ff3 100644 --- a/sdk/go/kubernetes/core/v1/podTemplatePatch.go +++ b/sdk/go/kubernetes/core/v1/podTemplatePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -119,6 +120,12 @@ func (i *PodTemplatePatch) ToPodTemplatePatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(PodTemplatePatchOutput) } +func (i *PodTemplatePatch) ToOutput(ctx context.Context) pulumix.Output[*PodTemplatePatch] { + return pulumix.Output[*PodTemplatePatch]{ + OutputState: i.ToPodTemplatePatchOutputWithContext(ctx).OutputState, + } +} + // PodTemplatePatchArrayInput is an input type that accepts PodTemplatePatchArray and PodTemplatePatchArrayOutput values. // You can construct a concrete instance of `PodTemplatePatchArrayInput` via: // @@ -144,6 +151,12 @@ func (i PodTemplatePatchArray) ToPodTemplatePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PodTemplatePatchArrayOutput) } +func (i PodTemplatePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodTemplatePatch] { + return pulumix.Output[[]*PodTemplatePatch]{ + OutputState: i.ToPodTemplatePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodTemplatePatchMapInput is an input type that accepts PodTemplatePatchMap and PodTemplatePatchMapOutput values. // You can construct a concrete instance of `PodTemplatePatchMapInput` via: // @@ -169,6 +182,12 @@ func (i PodTemplatePatchMap) ToPodTemplatePatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodTemplatePatchMapOutput) } +func (i PodTemplatePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodTemplatePatch] { + return pulumix.Output[map[string]*PodTemplatePatch]{ + OutputState: i.ToPodTemplatePatchMapOutputWithContext(ctx).OutputState, + } +} + type PodTemplatePatchOutput struct{ *pulumi.OutputState } func (PodTemplatePatchOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o PodTemplatePatchOutput) ToPodTemplatePatchOutputWithContext(ctx context. return o } +func (o PodTemplatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodTemplatePatch] { + return pulumix.Output[*PodTemplatePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTemplatePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodTemplatePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -217,6 +242,12 @@ func (o PodTemplatePatchArrayOutput) ToPodTemplatePatchArrayOutputWithContext(ct return o } +func (o PodTemplatePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodTemplatePatch] { + return pulumix.Output[[]*PodTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o PodTemplatePatchArrayOutput) Index(i pulumi.IntInput) PodTemplatePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodTemplatePatch { return vs[0].([]*PodTemplatePatch)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o PodTemplatePatchMapOutput) ToPodTemplatePatchMapOutputWithContext(ctx co return o } +func (o PodTemplatePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodTemplatePatch] { + return pulumix.Output[map[string]*PodTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o PodTemplatePatchMapOutput) MapIndex(k pulumi.StringInput) PodTemplatePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodTemplatePatch { return vs[0].(map[string]*PodTemplatePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/pulumiEnums.go b/sdk/go/kubernetes/core/v1/pulumiEnums.go index f9506c9ab9..6b49aafaea 100644 --- a/sdk/go/kubernetes/core/v1/pulumiEnums.go +++ b/sdk/go/kubernetes/core/v1/pulumiEnums.go @@ -8,6 +8,7 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) type ServiceSpecType string @@ -79,6 +80,12 @@ func (o ServiceSpecTypeOutput) ToServiceSpecTypePtrOutputWithContext(ctx context }).(ServiceSpecTypePtrOutput) } +func (o ServiceSpecTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceSpecType] { + return pulumix.Output[ServiceSpecType]{ + OutputState: o.OutputState, + } +} + func (o ServiceSpecTypeOutput) ToStringOutput() pulumi.StringOutput { return o.ToStringOutputWithContext(context.Background()) } @@ -114,6 +121,12 @@ func (o ServiceSpecTypePtrOutput) ToServiceSpecTypePtrOutputWithContext(ctx cont return o } +func (o ServiceSpecTypePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceSpecType] { + return pulumix.Output[*ServiceSpecType]{ + OutputState: o.OutputState, + } +} + func (o ServiceSpecTypePtrOutput) Elem() ServiceSpecTypeOutput { return o.ApplyT(func(v *ServiceSpecType) ServiceSpecType { if v != nil { @@ -176,6 +189,12 @@ func (in *serviceSpecTypePtr) ToServiceSpecTypePtrOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, in).(ServiceSpecTypePtrOutput) } +func (in *serviceSpecTypePtr) ToOutput(ctx context.Context) pulumix.Output[*ServiceSpecType] { + return pulumix.Output[*ServiceSpecType]{ + OutputState: in.ToServiceSpecTypePtrOutputWithContext(ctx).OutputState, + } +} + func init() { pulumi.RegisterInputType(reflect.TypeOf((*ServiceSpecTypeInput)(nil)).Elem(), ServiceSpecType("ExternalName")) pulumi.RegisterInputType(reflect.TypeOf((*ServiceSpecTypePtrInput)(nil)).Elem(), ServiceSpecType("ExternalName")) diff --git a/sdk/go/kubernetes/core/v1/pulumiTypes.go b/sdk/go/kubernetes/core/v1/pulumiTypes.go index ae1b1e8b48..537f17c730 100644 --- a/sdk/go/kubernetes/core/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/core/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -65,6 +66,12 @@ func (i AWSElasticBlockStoreVolumeSourceArgs) ToAWSElasticBlockStoreVolumeSource return pulumi.ToOutputWithContext(ctx, i).(AWSElasticBlockStoreVolumeSourceOutput) } +func (i AWSElasticBlockStoreVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[AWSElasticBlockStoreVolumeSource] { + return pulumix.Output[AWSElasticBlockStoreVolumeSource]{ + OutputState: i.ToAWSElasticBlockStoreVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i AWSElasticBlockStoreVolumeSourceArgs) ToAWSElasticBlockStoreVolumeSourcePtrOutput() AWSElasticBlockStoreVolumeSourcePtrOutput { return i.ToAWSElasticBlockStoreVolumeSourcePtrOutputWithContext(context.Background()) } @@ -106,6 +113,12 @@ func (i *awselasticBlockStoreVolumeSourcePtrType) ToAWSElasticBlockStoreVolumeSo return pulumi.ToOutputWithContext(ctx, i).(AWSElasticBlockStoreVolumeSourcePtrOutput) } +func (i *awselasticBlockStoreVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*AWSElasticBlockStoreVolumeSource] { + return pulumix.Output[*AWSElasticBlockStoreVolumeSource]{ + OutputState: i.ToAWSElasticBlockStoreVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Persistent Disk resource in AWS. // // An AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling. @@ -133,6 +146,12 @@ func (o AWSElasticBlockStoreVolumeSourceOutput) ToAWSElasticBlockStoreVolumeSour }).(AWSElasticBlockStoreVolumeSourcePtrOutput) } +func (o AWSElasticBlockStoreVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[AWSElasticBlockStoreVolumeSource] { + return pulumix.Output[AWSElasticBlockStoreVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore func (o AWSElasticBlockStoreVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v AWSElasticBlockStoreVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -167,6 +186,12 @@ func (o AWSElasticBlockStoreVolumeSourcePtrOutput) ToAWSElasticBlockStoreVolumeS return o } +func (o AWSElasticBlockStoreVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AWSElasticBlockStoreVolumeSource] { + return pulumix.Output[*AWSElasticBlockStoreVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o AWSElasticBlockStoreVolumeSourcePtrOutput) Elem() AWSElasticBlockStoreVolumeSourceOutput { return o.ApplyT(func(v *AWSElasticBlockStoreVolumeSource) AWSElasticBlockStoreVolumeSource { if v != nil { @@ -268,6 +293,12 @@ func (i AWSElasticBlockStoreVolumeSourcePatchArgs) ToAWSElasticBlockStoreVolumeS return pulumi.ToOutputWithContext(ctx, i).(AWSElasticBlockStoreVolumeSourcePatchOutput) } +func (i AWSElasticBlockStoreVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AWSElasticBlockStoreVolumeSourcePatch] { + return pulumix.Output[AWSElasticBlockStoreVolumeSourcePatch]{ + OutputState: i.ToAWSElasticBlockStoreVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i AWSElasticBlockStoreVolumeSourcePatchArgs) ToAWSElasticBlockStoreVolumeSourcePatchPtrOutput() AWSElasticBlockStoreVolumeSourcePatchPtrOutput { return i.ToAWSElasticBlockStoreVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -309,6 +340,12 @@ func (i *awselasticBlockStoreVolumeSourcePatchPtrType) ToAWSElasticBlockStoreVol return pulumi.ToOutputWithContext(ctx, i).(AWSElasticBlockStoreVolumeSourcePatchPtrOutput) } +func (i *awselasticBlockStoreVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AWSElasticBlockStoreVolumeSourcePatch] { + return pulumix.Output[*AWSElasticBlockStoreVolumeSourcePatch]{ + OutputState: i.ToAWSElasticBlockStoreVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Persistent Disk resource in AWS. // // An AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling. @@ -336,6 +373,12 @@ func (o AWSElasticBlockStoreVolumeSourcePatchOutput) ToAWSElasticBlockStoreVolum }).(AWSElasticBlockStoreVolumeSourcePatchPtrOutput) } +func (o AWSElasticBlockStoreVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AWSElasticBlockStoreVolumeSourcePatch] { + return pulumix.Output[AWSElasticBlockStoreVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore func (o AWSElasticBlockStoreVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v AWSElasticBlockStoreVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -370,6 +413,12 @@ func (o AWSElasticBlockStoreVolumeSourcePatchPtrOutput) ToAWSElasticBlockStoreVo return o } +func (o AWSElasticBlockStoreVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AWSElasticBlockStoreVolumeSourcePatch] { + return pulumix.Output[*AWSElasticBlockStoreVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o AWSElasticBlockStoreVolumeSourcePatchPtrOutput) Elem() AWSElasticBlockStoreVolumeSourcePatchOutput { return o.ApplyT(func(v *AWSElasticBlockStoreVolumeSourcePatch) AWSElasticBlockStoreVolumeSourcePatch { if v != nil { @@ -463,6 +512,12 @@ func (i AffinityArgs) ToAffinityOutputWithContext(ctx context.Context) AffinityO return pulumi.ToOutputWithContext(ctx, i).(AffinityOutput) } +func (i AffinityArgs) ToOutput(ctx context.Context) pulumix.Output[Affinity] { + return pulumix.Output[Affinity]{ + OutputState: i.ToAffinityOutputWithContext(ctx).OutputState, + } +} + func (i AffinityArgs) ToAffinityPtrOutput() AffinityPtrOutput { return i.ToAffinityPtrOutputWithContext(context.Background()) } @@ -504,6 +559,12 @@ func (i *affinityPtrType) ToAffinityPtrOutputWithContext(ctx context.Context) Af return pulumi.ToOutputWithContext(ctx, i).(AffinityPtrOutput) } +func (i *affinityPtrType) ToOutput(ctx context.Context) pulumix.Output[*Affinity] { + return pulumix.Output[*Affinity]{ + OutputState: i.ToAffinityPtrOutputWithContext(ctx).OutputState, + } +} + // Affinity is a group of affinity scheduling rules. type AffinityOutput struct{ *pulumi.OutputState } @@ -529,6 +590,12 @@ func (o AffinityOutput) ToAffinityPtrOutputWithContext(ctx context.Context) Affi }).(AffinityPtrOutput) } +func (o AffinityOutput) ToOutput(ctx context.Context) pulumix.Output[Affinity] { + return pulumix.Output[Affinity]{ + OutputState: o.OutputState, + } +} + // Describes node affinity scheduling rules for the pod. func (o AffinityOutput) NodeAffinity() NodeAffinityPtrOutput { return o.ApplyT(func(v Affinity) *NodeAffinity { return v.NodeAffinity }).(NodeAffinityPtrOutput) @@ -558,6 +625,12 @@ func (o AffinityPtrOutput) ToAffinityPtrOutputWithContext(ctx context.Context) A return o } +func (o AffinityPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Affinity] { + return pulumix.Output[*Affinity]{ + OutputState: o.OutputState, + } +} + func (o AffinityPtrOutput) Elem() AffinityOutput { return o.ApplyT(func(v *Affinity) Affinity { if v != nil { @@ -641,6 +714,12 @@ func (i AffinityPatchArgs) ToAffinityPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(AffinityPatchOutput) } +func (i AffinityPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AffinityPatch] { + return pulumix.Output[AffinityPatch]{ + OutputState: i.ToAffinityPatchOutputWithContext(ctx).OutputState, + } +} + func (i AffinityPatchArgs) ToAffinityPatchPtrOutput() AffinityPatchPtrOutput { return i.ToAffinityPatchPtrOutputWithContext(context.Background()) } @@ -682,6 +761,12 @@ func (i *affinityPatchPtrType) ToAffinityPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(AffinityPatchPtrOutput) } +func (i *affinityPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AffinityPatch] { + return pulumix.Output[*AffinityPatch]{ + OutputState: i.ToAffinityPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Affinity is a group of affinity scheduling rules. type AffinityPatchOutput struct{ *pulumi.OutputState } @@ -707,6 +792,12 @@ func (o AffinityPatchOutput) ToAffinityPatchPtrOutputWithContext(ctx context.Con }).(AffinityPatchPtrOutput) } +func (o AffinityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AffinityPatch] { + return pulumix.Output[AffinityPatch]{ + OutputState: o.OutputState, + } +} + // Describes node affinity scheduling rules for the pod. func (o AffinityPatchOutput) NodeAffinity() NodeAffinityPatchPtrOutput { return o.ApplyT(func(v AffinityPatch) *NodeAffinityPatch { return v.NodeAffinity }).(NodeAffinityPatchPtrOutput) @@ -736,6 +827,12 @@ func (o AffinityPatchPtrOutput) ToAffinityPatchPtrOutputWithContext(ctx context. return o } +func (o AffinityPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AffinityPatch] { + return pulumix.Output[*AffinityPatch]{ + OutputState: o.OutputState, + } +} + func (o AffinityPatchPtrOutput) Elem() AffinityPatchOutput { return o.ApplyT(func(v *AffinityPatch) AffinityPatch { if v != nil { @@ -815,6 +912,12 @@ func (i AttachedVolumeArgs) ToAttachedVolumeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(AttachedVolumeOutput) } +func (i AttachedVolumeArgs) ToOutput(ctx context.Context) pulumix.Output[AttachedVolume] { + return pulumix.Output[AttachedVolume]{ + OutputState: i.ToAttachedVolumeOutputWithContext(ctx).OutputState, + } +} + // AttachedVolumeArrayInput is an input type that accepts AttachedVolumeArray and AttachedVolumeArrayOutput values. // You can construct a concrete instance of `AttachedVolumeArrayInput` via: // @@ -840,6 +943,12 @@ func (i AttachedVolumeArray) ToAttachedVolumeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AttachedVolumeArrayOutput) } +func (i AttachedVolumeArray) ToOutput(ctx context.Context) pulumix.Output[[]AttachedVolume] { + return pulumix.Output[[]AttachedVolume]{ + OutputState: i.ToAttachedVolumeArrayOutputWithContext(ctx).OutputState, + } +} + // AttachedVolume describes a volume attached to a node type AttachedVolumeOutput struct{ *pulumi.OutputState } @@ -855,6 +964,12 @@ func (o AttachedVolumeOutput) ToAttachedVolumeOutputWithContext(ctx context.Cont return o } +func (o AttachedVolumeOutput) ToOutput(ctx context.Context) pulumix.Output[AttachedVolume] { + return pulumix.Output[AttachedVolume]{ + OutputState: o.OutputState, + } +} + // DevicePath represents the device path where the volume should be available func (o AttachedVolumeOutput) DevicePath() pulumi.StringOutput { return o.ApplyT(func(v AttachedVolume) string { return v.DevicePath }).(pulumi.StringOutput) @@ -879,6 +994,12 @@ func (o AttachedVolumeArrayOutput) ToAttachedVolumeArrayOutputWithContext(ctx co return o } +func (o AttachedVolumeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AttachedVolume] { + return pulumix.Output[[]AttachedVolume]{ + OutputState: o.OutputState, + } +} + func (o AttachedVolumeArrayOutput) Index(i pulumi.IntInput) AttachedVolumeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AttachedVolume { return vs[0].([]AttachedVolume)[vs[1].(int)] @@ -924,6 +1045,12 @@ func (i AttachedVolumePatchArgs) ToAttachedVolumePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(AttachedVolumePatchOutput) } +func (i AttachedVolumePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AttachedVolumePatch] { + return pulumix.Output[AttachedVolumePatch]{ + OutputState: i.ToAttachedVolumePatchOutputWithContext(ctx).OutputState, + } +} + // AttachedVolumePatchArrayInput is an input type that accepts AttachedVolumePatchArray and AttachedVolumePatchArrayOutput values. // You can construct a concrete instance of `AttachedVolumePatchArrayInput` via: // @@ -949,6 +1076,12 @@ func (i AttachedVolumePatchArray) ToAttachedVolumePatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(AttachedVolumePatchArrayOutput) } +func (i AttachedVolumePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AttachedVolumePatch] { + return pulumix.Output[[]AttachedVolumePatch]{ + OutputState: i.ToAttachedVolumePatchArrayOutputWithContext(ctx).OutputState, + } +} + // AttachedVolume describes a volume attached to a node type AttachedVolumePatchOutput struct{ *pulumi.OutputState } @@ -964,6 +1097,12 @@ func (o AttachedVolumePatchOutput) ToAttachedVolumePatchOutputWithContext(ctx co return o } +func (o AttachedVolumePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AttachedVolumePatch] { + return pulumix.Output[AttachedVolumePatch]{ + OutputState: o.OutputState, + } +} + // DevicePath represents the device path where the volume should be available func (o AttachedVolumePatchOutput) DevicePath() pulumi.StringPtrOutput { return o.ApplyT(func(v AttachedVolumePatch) *string { return v.DevicePath }).(pulumi.StringPtrOutput) @@ -988,6 +1127,12 @@ func (o AttachedVolumePatchArrayOutput) ToAttachedVolumePatchArrayOutputWithCont return o } +func (o AttachedVolumePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AttachedVolumePatch] { + return pulumix.Output[[]AttachedVolumePatch]{ + OutputState: o.OutputState, + } +} + func (o AttachedVolumePatchArrayOutput) Index(i pulumi.IntInput) AttachedVolumePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AttachedVolumePatch { return vs[0].([]AttachedVolumePatch)[vs[1].(int)] @@ -1049,6 +1194,12 @@ func (i AzureDiskVolumeSourceArgs) ToAzureDiskVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AzureDiskVolumeSourceOutput) } +func (i AzureDiskVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[AzureDiskVolumeSource] { + return pulumix.Output[AzureDiskVolumeSource]{ + OutputState: i.ToAzureDiskVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i AzureDiskVolumeSourceArgs) ToAzureDiskVolumeSourcePtrOutput() AzureDiskVolumeSourcePtrOutput { return i.ToAzureDiskVolumeSourcePtrOutputWithContext(context.Background()) } @@ -1090,6 +1241,12 @@ func (i *azureDiskVolumeSourcePtrType) ToAzureDiskVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(AzureDiskVolumeSourcePtrOutput) } +func (i *azureDiskVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*AzureDiskVolumeSource] { + return pulumix.Output[*AzureDiskVolumeSource]{ + OutputState: i.ToAzureDiskVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. type AzureDiskVolumeSourceOutput struct{ *pulumi.OutputState } @@ -1115,6 +1272,12 @@ func (o AzureDiskVolumeSourceOutput) ToAzureDiskVolumeSourcePtrOutputWithContext }).(AzureDiskVolumeSourcePtrOutput) } +func (o AzureDiskVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[AzureDiskVolumeSource] { + return pulumix.Output[AzureDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + // cachingMode is the Host Caching mode: None, Read Only, Read Write. func (o AzureDiskVolumeSourceOutput) CachingMode() pulumi.StringPtrOutput { return o.ApplyT(func(v AzureDiskVolumeSource) *string { return v.CachingMode }).(pulumi.StringPtrOutput) @@ -1159,6 +1322,12 @@ func (o AzureDiskVolumeSourcePtrOutput) ToAzureDiskVolumeSourcePtrOutputWithCont return o } +func (o AzureDiskVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureDiskVolumeSource] { + return pulumix.Output[*AzureDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o AzureDiskVolumeSourcePtrOutput) Elem() AzureDiskVolumeSourceOutput { return o.ApplyT(func(v *AzureDiskVolumeSource) AzureDiskVolumeSource { if v != nil { @@ -1284,6 +1453,12 @@ func (i AzureDiskVolumeSourcePatchArgs) ToAzureDiskVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(AzureDiskVolumeSourcePatchOutput) } +func (i AzureDiskVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AzureDiskVolumeSourcePatch] { + return pulumix.Output[AzureDiskVolumeSourcePatch]{ + OutputState: i.ToAzureDiskVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i AzureDiskVolumeSourcePatchArgs) ToAzureDiskVolumeSourcePatchPtrOutput() AzureDiskVolumeSourcePatchPtrOutput { return i.ToAzureDiskVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -1325,6 +1500,12 @@ func (i *azureDiskVolumeSourcePatchPtrType) ToAzureDiskVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(AzureDiskVolumeSourcePatchPtrOutput) } +func (i *azureDiskVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AzureDiskVolumeSourcePatch] { + return pulumix.Output[*AzureDiskVolumeSourcePatch]{ + OutputState: i.ToAzureDiskVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. type AzureDiskVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -1350,6 +1531,12 @@ func (o AzureDiskVolumeSourcePatchOutput) ToAzureDiskVolumeSourcePatchPtrOutputW }).(AzureDiskVolumeSourcePatchPtrOutput) } +func (o AzureDiskVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AzureDiskVolumeSourcePatch] { + return pulumix.Output[AzureDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // cachingMode is the Host Caching mode: None, Read Only, Read Write. func (o AzureDiskVolumeSourcePatchOutput) CachingMode() pulumi.StringPtrOutput { return o.ApplyT(func(v AzureDiskVolumeSourcePatch) *string { return v.CachingMode }).(pulumi.StringPtrOutput) @@ -1394,6 +1581,12 @@ func (o AzureDiskVolumeSourcePatchPtrOutput) ToAzureDiskVolumeSourcePatchPtrOutp return o } +func (o AzureDiskVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureDiskVolumeSourcePatch] { + return pulumix.Output[*AzureDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o AzureDiskVolumeSourcePatchPtrOutput) Elem() AzureDiskVolumeSourcePatchOutput { return o.ApplyT(func(v *AzureDiskVolumeSourcePatch) AzureDiskVolumeSourcePatch { if v != nil { @@ -1511,6 +1704,12 @@ func (i AzureFilePersistentVolumeSourceArgs) ToAzureFilePersistentVolumeSourceOu return pulumi.ToOutputWithContext(ctx, i).(AzureFilePersistentVolumeSourceOutput) } +func (i AzureFilePersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[AzureFilePersistentVolumeSource] { + return pulumix.Output[AzureFilePersistentVolumeSource]{ + OutputState: i.ToAzureFilePersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i AzureFilePersistentVolumeSourceArgs) ToAzureFilePersistentVolumeSourcePtrOutput() AzureFilePersistentVolumeSourcePtrOutput { return i.ToAzureFilePersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -1552,6 +1751,12 @@ func (i *azureFilePersistentVolumeSourcePtrType) ToAzureFilePersistentVolumeSour return pulumi.ToOutputWithContext(ctx, i).(AzureFilePersistentVolumeSourcePtrOutput) } +func (i *azureFilePersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*AzureFilePersistentVolumeSource] { + return pulumix.Output[*AzureFilePersistentVolumeSource]{ + OutputState: i.ToAzureFilePersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // AzureFile represents an Azure File Service mount on the host and bind mount to the pod. type AzureFilePersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -1577,6 +1782,12 @@ func (o AzureFilePersistentVolumeSourceOutput) ToAzureFilePersistentVolumeSource }).(AzureFilePersistentVolumeSourcePtrOutput) } +func (o AzureFilePersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[AzureFilePersistentVolumeSource] { + return pulumix.Output[AzureFilePersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. func (o AzureFilePersistentVolumeSourceOutput) ReadOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v AzureFilePersistentVolumeSource) *bool { return v.ReadOnly }).(pulumi.BoolPtrOutput) @@ -1611,6 +1822,12 @@ func (o AzureFilePersistentVolumeSourcePtrOutput) ToAzureFilePersistentVolumeSou return o } +func (o AzureFilePersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureFilePersistentVolumeSource] { + return pulumix.Output[*AzureFilePersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o AzureFilePersistentVolumeSourcePtrOutput) Elem() AzureFilePersistentVolumeSourceOutput { return o.ApplyT(func(v *AzureFilePersistentVolumeSource) AzureFilePersistentVolumeSource { if v != nil { @@ -1708,6 +1925,12 @@ func (i AzureFilePersistentVolumeSourcePatchArgs) ToAzureFilePersistentVolumeSou return pulumi.ToOutputWithContext(ctx, i).(AzureFilePersistentVolumeSourcePatchOutput) } +func (i AzureFilePersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AzureFilePersistentVolumeSourcePatch] { + return pulumix.Output[AzureFilePersistentVolumeSourcePatch]{ + OutputState: i.ToAzureFilePersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i AzureFilePersistentVolumeSourcePatchArgs) ToAzureFilePersistentVolumeSourcePatchPtrOutput() AzureFilePersistentVolumeSourcePatchPtrOutput { return i.ToAzureFilePersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -1749,6 +1972,12 @@ func (i *azureFilePersistentVolumeSourcePatchPtrType) ToAzureFilePersistentVolum return pulumi.ToOutputWithContext(ctx, i).(AzureFilePersistentVolumeSourcePatchPtrOutput) } +func (i *azureFilePersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AzureFilePersistentVolumeSourcePatch] { + return pulumix.Output[*AzureFilePersistentVolumeSourcePatch]{ + OutputState: i.ToAzureFilePersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // AzureFile represents an Azure File Service mount on the host and bind mount to the pod. type AzureFilePersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -1774,6 +2003,12 @@ func (o AzureFilePersistentVolumeSourcePatchOutput) ToAzureFilePersistentVolumeS }).(AzureFilePersistentVolumeSourcePatchPtrOutput) } +func (o AzureFilePersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AzureFilePersistentVolumeSourcePatch] { + return pulumix.Output[AzureFilePersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. func (o AzureFilePersistentVolumeSourcePatchOutput) ReadOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v AzureFilePersistentVolumeSourcePatch) *bool { return v.ReadOnly }).(pulumi.BoolPtrOutput) @@ -1808,6 +2043,12 @@ func (o AzureFilePersistentVolumeSourcePatchPtrOutput) ToAzureFilePersistentVolu return o } +func (o AzureFilePersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureFilePersistentVolumeSourcePatch] { + return pulumix.Output[*AzureFilePersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o AzureFilePersistentVolumeSourcePatchPtrOutput) Elem() AzureFilePersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *AzureFilePersistentVolumeSourcePatch) AzureFilePersistentVolumeSourcePatch { if v != nil { @@ -1901,6 +2142,12 @@ func (i AzureFileVolumeSourceArgs) ToAzureFileVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AzureFileVolumeSourceOutput) } +func (i AzureFileVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[AzureFileVolumeSource] { + return pulumix.Output[AzureFileVolumeSource]{ + OutputState: i.ToAzureFileVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i AzureFileVolumeSourceArgs) ToAzureFileVolumeSourcePtrOutput() AzureFileVolumeSourcePtrOutput { return i.ToAzureFileVolumeSourcePtrOutputWithContext(context.Background()) } @@ -1942,6 +2189,12 @@ func (i *azureFileVolumeSourcePtrType) ToAzureFileVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(AzureFileVolumeSourcePtrOutput) } +func (i *azureFileVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*AzureFileVolumeSource] { + return pulumix.Output[*AzureFileVolumeSource]{ + OutputState: i.ToAzureFileVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // AzureFile represents an Azure File Service mount on the host and bind mount to the pod. type AzureFileVolumeSourceOutput struct{ *pulumi.OutputState } @@ -1967,6 +2220,12 @@ func (o AzureFileVolumeSourceOutput) ToAzureFileVolumeSourcePtrOutputWithContext }).(AzureFileVolumeSourcePtrOutput) } +func (o AzureFileVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[AzureFileVolumeSource] { + return pulumix.Output[AzureFileVolumeSource]{ + OutputState: o.OutputState, + } +} + // readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. func (o AzureFileVolumeSourceOutput) ReadOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v AzureFileVolumeSource) *bool { return v.ReadOnly }).(pulumi.BoolPtrOutput) @@ -1996,6 +2255,12 @@ func (o AzureFileVolumeSourcePtrOutput) ToAzureFileVolumeSourcePtrOutputWithCont return o } +func (o AzureFileVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureFileVolumeSource] { + return pulumix.Output[*AzureFileVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o AzureFileVolumeSourcePtrOutput) Elem() AzureFileVolumeSourceOutput { return o.ApplyT(func(v *AzureFileVolumeSource) AzureFileVolumeSource { if v != nil { @@ -2079,6 +2344,12 @@ func (i AzureFileVolumeSourcePatchArgs) ToAzureFileVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(AzureFileVolumeSourcePatchOutput) } +func (i AzureFileVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AzureFileVolumeSourcePatch] { + return pulumix.Output[AzureFileVolumeSourcePatch]{ + OutputState: i.ToAzureFileVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i AzureFileVolumeSourcePatchArgs) ToAzureFileVolumeSourcePatchPtrOutput() AzureFileVolumeSourcePatchPtrOutput { return i.ToAzureFileVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -2120,6 +2391,12 @@ func (i *azureFileVolumeSourcePatchPtrType) ToAzureFileVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(AzureFileVolumeSourcePatchPtrOutput) } +func (i *azureFileVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AzureFileVolumeSourcePatch] { + return pulumix.Output[*AzureFileVolumeSourcePatch]{ + OutputState: i.ToAzureFileVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // AzureFile represents an Azure File Service mount on the host and bind mount to the pod. type AzureFileVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -2145,6 +2422,12 @@ func (o AzureFileVolumeSourcePatchOutput) ToAzureFileVolumeSourcePatchPtrOutputW }).(AzureFileVolumeSourcePatchPtrOutput) } +func (o AzureFileVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AzureFileVolumeSourcePatch] { + return pulumix.Output[AzureFileVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. func (o AzureFileVolumeSourcePatchOutput) ReadOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v AzureFileVolumeSourcePatch) *bool { return v.ReadOnly }).(pulumi.BoolPtrOutput) @@ -2174,6 +2457,12 @@ func (o AzureFileVolumeSourcePatchPtrOutput) ToAzureFileVolumeSourcePatchPtrOutp return o } +func (o AzureFileVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureFileVolumeSourcePatch] { + return pulumix.Output[*AzureFileVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o AzureFileVolumeSourcePatchPtrOutput) Elem() AzureFileVolumeSourcePatchOutput { return o.ApplyT(func(v *AzureFileVolumeSourcePatch) AzureFileVolumeSourcePatch { if v != nil { @@ -2261,6 +2550,12 @@ func (i BindingTypeArgs) ToBindingTypeOutputWithContext(ctx context.Context) Bin return pulumi.ToOutputWithContext(ctx, i).(BindingTypeOutput) } +func (i BindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[BindingType] { + return pulumix.Output[BindingType]{ + OutputState: i.ToBindingTypeOutputWithContext(ctx).OutputState, + } +} + // Binding ties one object to another; for example, a pod is bound to a node by a scheduler. Deprecated in 1.7, please use the bindings subresource of pods instead. type BindingTypeOutput struct{ *pulumi.OutputState } @@ -2276,6 +2571,12 @@ func (o BindingTypeOutput) ToBindingTypeOutputWithContext(ctx context.Context) B return o } +func (o BindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[BindingType] { + return pulumix.Output[BindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o BindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v BindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2343,6 +2644,12 @@ func (i BindingPatchTypeArgs) ToBindingPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(BindingPatchTypeOutput) } +func (i BindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[BindingPatchType] { + return pulumix.Output[BindingPatchType]{ + OutputState: i.ToBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Binding ties one object to another; for example, a pod is bound to a node by a scheduler. Deprecated in 1.7, please use the bindings subresource of pods instead. type BindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -2358,6 +2665,12 @@ func (o BindingPatchTypeOutput) ToBindingPatchTypeOutputWithContext(ctx context. return o } +func (o BindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[BindingPatchType] { + return pulumix.Output[BindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o BindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v BindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2449,6 +2762,12 @@ func (i CSIPersistentVolumeSourceArgs) ToCSIPersistentVolumeSourceOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CSIPersistentVolumeSourceOutput) } +func (i CSIPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[CSIPersistentVolumeSource] { + return pulumix.Output[CSIPersistentVolumeSource]{ + OutputState: i.ToCSIPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i CSIPersistentVolumeSourceArgs) ToCSIPersistentVolumeSourcePtrOutput() CSIPersistentVolumeSourcePtrOutput { return i.ToCSIPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -2490,6 +2809,12 @@ func (i *csipersistentVolumeSourcePtrType) ToCSIPersistentVolumeSourcePtrOutputW return pulumi.ToOutputWithContext(ctx, i).(CSIPersistentVolumeSourcePtrOutput) } +func (i *csipersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*CSIPersistentVolumeSource] { + return pulumix.Output[*CSIPersistentVolumeSource]{ + OutputState: i.ToCSIPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents storage that is managed by an external CSI volume driver (Beta feature) type CSIPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -2515,6 +2840,12 @@ func (o CSIPersistentVolumeSourceOutput) ToCSIPersistentVolumeSourcePtrOutputWit }).(CSIPersistentVolumeSourcePtrOutput) } +func (o CSIPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[CSIPersistentVolumeSource] { + return pulumix.Output[CSIPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // controllerExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerExpandVolume call. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed. func (o CSIPersistentVolumeSourceOutput) ControllerExpandSecretRef() SecretReferencePtrOutput { return o.ApplyT(func(v CSIPersistentVolumeSource) *SecretReference { return v.ControllerExpandSecretRef }).(SecretReferencePtrOutput) @@ -2579,6 +2910,12 @@ func (o CSIPersistentVolumeSourcePtrOutput) ToCSIPersistentVolumeSourcePtrOutput return o } +func (o CSIPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIPersistentVolumeSource] { + return pulumix.Output[*CSIPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o CSIPersistentVolumeSourcePtrOutput) Elem() CSIPersistentVolumeSourceOutput { return o.ApplyT(func(v *CSIPersistentVolumeSource) CSIPersistentVolumeSource { if v != nil { @@ -2760,6 +3097,12 @@ func (i CSIPersistentVolumeSourcePatchArgs) ToCSIPersistentVolumeSourcePatchOutp return pulumi.ToOutputWithContext(ctx, i).(CSIPersistentVolumeSourcePatchOutput) } +func (i CSIPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSIPersistentVolumeSourcePatch] { + return pulumix.Output[CSIPersistentVolumeSourcePatch]{ + OutputState: i.ToCSIPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i CSIPersistentVolumeSourcePatchArgs) ToCSIPersistentVolumeSourcePatchPtrOutput() CSIPersistentVolumeSourcePatchPtrOutput { return i.ToCSIPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -2801,6 +3144,12 @@ func (i *csipersistentVolumeSourcePatchPtrType) ToCSIPersistentVolumeSourcePatch return pulumi.ToOutputWithContext(ctx, i).(CSIPersistentVolumeSourcePatchPtrOutput) } +func (i *csipersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CSIPersistentVolumeSourcePatch] { + return pulumix.Output[*CSIPersistentVolumeSourcePatch]{ + OutputState: i.ToCSIPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents storage that is managed by an external CSI volume driver (Beta feature) type CSIPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -2826,6 +3175,12 @@ func (o CSIPersistentVolumeSourcePatchOutput) ToCSIPersistentVolumeSourcePatchPt }).(CSIPersistentVolumeSourcePatchPtrOutput) } +func (o CSIPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSIPersistentVolumeSourcePatch] { + return pulumix.Output[CSIPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // controllerExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerExpandVolume call. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed. func (o CSIPersistentVolumeSourcePatchOutput) ControllerExpandSecretRef() SecretReferencePatchPtrOutput { return o.ApplyT(func(v CSIPersistentVolumeSourcePatch) *SecretReferencePatch { return v.ControllerExpandSecretRef }).(SecretReferencePatchPtrOutput) @@ -2890,6 +3245,12 @@ func (o CSIPersistentVolumeSourcePatchPtrOutput) ToCSIPersistentVolumeSourcePatc return o } +func (o CSIPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIPersistentVolumeSourcePatch] { + return pulumix.Output[*CSIPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o CSIPersistentVolumeSourcePatchPtrOutput) Elem() CSIPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *CSIPersistentVolumeSourcePatch) CSIPersistentVolumeSourcePatch { if v != nil { @@ -3051,6 +3412,12 @@ func (i CSIVolumeSourceArgs) ToCSIVolumeSourceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSIVolumeSourceOutput) } +func (i CSIVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[CSIVolumeSource] { + return pulumix.Output[CSIVolumeSource]{ + OutputState: i.ToCSIVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i CSIVolumeSourceArgs) ToCSIVolumeSourcePtrOutput() CSIVolumeSourcePtrOutput { return i.ToCSIVolumeSourcePtrOutputWithContext(context.Background()) } @@ -3092,6 +3459,12 @@ func (i *csivolumeSourcePtrType) ToCSIVolumeSourcePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(CSIVolumeSourcePtrOutput) } +func (i *csivolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*CSIVolumeSource] { + return pulumix.Output[*CSIVolumeSource]{ + OutputState: i.ToCSIVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a source location of a volume to mount, managed by an external CSI driver type CSIVolumeSourceOutput struct{ *pulumi.OutputState } @@ -3117,6 +3490,12 @@ func (o CSIVolumeSourceOutput) ToCSIVolumeSourcePtrOutputWithContext(ctx context }).(CSIVolumeSourcePtrOutput) } +func (o CSIVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[CSIVolumeSource] { + return pulumix.Output[CSIVolumeSource]{ + OutputState: o.OutputState, + } +} + // driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster. func (o CSIVolumeSourceOutput) Driver() pulumi.StringOutput { return o.ApplyT(func(v CSIVolumeSource) string { return v.Driver }).(pulumi.StringOutput) @@ -3156,6 +3535,12 @@ func (o CSIVolumeSourcePtrOutput) ToCSIVolumeSourcePtrOutputWithContext(ctx cont return o } +func (o CSIVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIVolumeSource] { + return pulumix.Output[*CSIVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o CSIVolumeSourcePtrOutput) Elem() CSIVolumeSourceOutput { return o.ApplyT(func(v *CSIVolumeSource) CSIVolumeSource { if v != nil { @@ -3267,6 +3652,12 @@ func (i CSIVolumeSourcePatchArgs) ToCSIVolumeSourcePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(CSIVolumeSourcePatchOutput) } +func (i CSIVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSIVolumeSourcePatch] { + return pulumix.Output[CSIVolumeSourcePatch]{ + OutputState: i.ToCSIVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i CSIVolumeSourcePatchArgs) ToCSIVolumeSourcePatchPtrOutput() CSIVolumeSourcePatchPtrOutput { return i.ToCSIVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -3308,6 +3699,12 @@ func (i *csivolumeSourcePatchPtrType) ToCSIVolumeSourcePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(CSIVolumeSourcePatchPtrOutput) } +func (i *csivolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CSIVolumeSourcePatch] { + return pulumix.Output[*CSIVolumeSourcePatch]{ + OutputState: i.ToCSIVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a source location of a volume to mount, managed by an external CSI driver type CSIVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -3333,6 +3730,12 @@ func (o CSIVolumeSourcePatchOutput) ToCSIVolumeSourcePatchPtrOutputWithContext(c }).(CSIVolumeSourcePatchPtrOutput) } +func (o CSIVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSIVolumeSourcePatch] { + return pulumix.Output[CSIVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster. func (o CSIVolumeSourcePatchOutput) Driver() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIVolumeSourcePatch) *string { return v.Driver }).(pulumi.StringPtrOutput) @@ -3372,6 +3775,12 @@ func (o CSIVolumeSourcePatchPtrOutput) ToCSIVolumeSourcePatchPtrOutputWithContex return o } +func (o CSIVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIVolumeSourcePatch] { + return pulumix.Output[*CSIVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o CSIVolumeSourcePatchPtrOutput) Elem() CSIVolumeSourcePatchOutput { return o.ApplyT(func(v *CSIVolumeSourcePatch) CSIVolumeSourcePatch { if v != nil { @@ -3471,6 +3880,12 @@ func (i CapabilitiesArgs) ToCapabilitiesOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CapabilitiesOutput) } +func (i CapabilitiesArgs) ToOutput(ctx context.Context) pulumix.Output[Capabilities] { + return pulumix.Output[Capabilities]{ + OutputState: i.ToCapabilitiesOutputWithContext(ctx).OutputState, + } +} + func (i CapabilitiesArgs) ToCapabilitiesPtrOutput() CapabilitiesPtrOutput { return i.ToCapabilitiesPtrOutputWithContext(context.Background()) } @@ -3512,6 +3927,12 @@ func (i *capabilitiesPtrType) ToCapabilitiesPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(CapabilitiesPtrOutput) } +func (i *capabilitiesPtrType) ToOutput(ctx context.Context) pulumix.Output[*Capabilities] { + return pulumix.Output[*Capabilities]{ + OutputState: i.ToCapabilitiesPtrOutputWithContext(ctx).OutputState, + } +} + // Adds and removes POSIX capabilities from running containers. type CapabilitiesOutput struct{ *pulumi.OutputState } @@ -3537,6 +3958,12 @@ func (o CapabilitiesOutput) ToCapabilitiesPtrOutputWithContext(ctx context.Conte }).(CapabilitiesPtrOutput) } +func (o CapabilitiesOutput) ToOutput(ctx context.Context) pulumix.Output[Capabilities] { + return pulumix.Output[Capabilities]{ + OutputState: o.OutputState, + } +} + // Added capabilities func (o CapabilitiesOutput) Add() pulumi.StringArrayOutput { return o.ApplyT(func(v Capabilities) []string { return v.Add }).(pulumi.StringArrayOutput) @@ -3561,6 +3988,12 @@ func (o CapabilitiesPtrOutput) ToCapabilitiesPtrOutputWithContext(ctx context.Co return o } +func (o CapabilitiesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Capabilities] { + return pulumix.Output[*Capabilities]{ + OutputState: o.OutputState, + } +} + func (o CapabilitiesPtrOutput) Elem() CapabilitiesOutput { return o.ApplyT(func(v *Capabilities) Capabilities { if v != nil { @@ -3630,6 +4063,12 @@ func (i CapabilitiesPatchArgs) ToCapabilitiesPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(CapabilitiesPatchOutput) } +func (i CapabilitiesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CapabilitiesPatch] { + return pulumix.Output[CapabilitiesPatch]{ + OutputState: i.ToCapabilitiesPatchOutputWithContext(ctx).OutputState, + } +} + func (i CapabilitiesPatchArgs) ToCapabilitiesPatchPtrOutput() CapabilitiesPatchPtrOutput { return i.ToCapabilitiesPatchPtrOutputWithContext(context.Background()) } @@ -3671,6 +4110,12 @@ func (i *capabilitiesPatchPtrType) ToCapabilitiesPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(CapabilitiesPatchPtrOutput) } +func (i *capabilitiesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CapabilitiesPatch] { + return pulumix.Output[*CapabilitiesPatch]{ + OutputState: i.ToCapabilitiesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Adds and removes POSIX capabilities from running containers. type CapabilitiesPatchOutput struct{ *pulumi.OutputState } @@ -3696,6 +4141,12 @@ func (o CapabilitiesPatchOutput) ToCapabilitiesPatchPtrOutputWithContext(ctx con }).(CapabilitiesPatchPtrOutput) } +func (o CapabilitiesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CapabilitiesPatch] { + return pulumix.Output[CapabilitiesPatch]{ + OutputState: o.OutputState, + } +} + // Added capabilities func (o CapabilitiesPatchOutput) Add() pulumi.StringArrayOutput { return o.ApplyT(func(v CapabilitiesPatch) []string { return v.Add }).(pulumi.StringArrayOutput) @@ -3720,6 +4171,12 @@ func (o CapabilitiesPatchPtrOutput) ToCapabilitiesPatchPtrOutputWithContext(ctx return o } +func (o CapabilitiesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CapabilitiesPatch] { + return pulumix.Output[*CapabilitiesPatch]{ + OutputState: o.OutputState, + } +} + func (o CapabilitiesPatchPtrOutput) Elem() CapabilitiesPatchOutput { return o.ApplyT(func(v *CapabilitiesPatch) CapabilitiesPatch { if v != nil { @@ -3805,6 +4262,12 @@ func (i CephFSPersistentVolumeSourceArgs) ToCephFSPersistentVolumeSourceOutputWi return pulumi.ToOutputWithContext(ctx, i).(CephFSPersistentVolumeSourceOutput) } +func (i CephFSPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[CephFSPersistentVolumeSource] { + return pulumix.Output[CephFSPersistentVolumeSource]{ + OutputState: i.ToCephFSPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i CephFSPersistentVolumeSourceArgs) ToCephFSPersistentVolumeSourcePtrOutput() CephFSPersistentVolumeSourcePtrOutput { return i.ToCephFSPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -3846,6 +4309,12 @@ func (i *cephFSPersistentVolumeSourcePtrType) ToCephFSPersistentVolumeSourcePtrO return pulumi.ToOutputWithContext(ctx, i).(CephFSPersistentVolumeSourcePtrOutput) } +func (i *cephFSPersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*CephFSPersistentVolumeSource] { + return pulumix.Output[*CephFSPersistentVolumeSource]{ + OutputState: i.ToCephFSPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. type CephFSPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -3871,6 +4340,12 @@ func (o CephFSPersistentVolumeSourceOutput) ToCephFSPersistentVolumeSourcePtrOut }).(CephFSPersistentVolumeSourcePtrOutput) } +func (o CephFSPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[CephFSPersistentVolumeSource] { + return pulumix.Output[CephFSPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it func (o CephFSPersistentVolumeSourceOutput) Monitors() pulumi.StringArrayOutput { return o.ApplyT(func(v CephFSPersistentVolumeSource) []string { return v.Monitors }).(pulumi.StringArrayOutput) @@ -3915,6 +4390,12 @@ func (o CephFSPersistentVolumeSourcePtrOutput) ToCephFSPersistentVolumeSourcePtr return o } +func (o CephFSPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CephFSPersistentVolumeSource] { + return pulumix.Output[*CephFSPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o CephFSPersistentVolumeSourcePtrOutput) Elem() CephFSPersistentVolumeSourceOutput { return o.ApplyT(func(v *CephFSPersistentVolumeSource) CephFSPersistentVolumeSource { if v != nil { @@ -4040,6 +4521,12 @@ func (i CephFSPersistentVolumeSourcePatchArgs) ToCephFSPersistentVolumeSourcePat return pulumi.ToOutputWithContext(ctx, i).(CephFSPersistentVolumeSourcePatchOutput) } +func (i CephFSPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CephFSPersistentVolumeSourcePatch] { + return pulumix.Output[CephFSPersistentVolumeSourcePatch]{ + OutputState: i.ToCephFSPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i CephFSPersistentVolumeSourcePatchArgs) ToCephFSPersistentVolumeSourcePatchPtrOutput() CephFSPersistentVolumeSourcePatchPtrOutput { return i.ToCephFSPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -4081,6 +4568,12 @@ func (i *cephFSPersistentVolumeSourcePatchPtrType) ToCephFSPersistentVolumeSourc return pulumi.ToOutputWithContext(ctx, i).(CephFSPersistentVolumeSourcePatchPtrOutput) } +func (i *cephFSPersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CephFSPersistentVolumeSourcePatch] { + return pulumix.Output[*CephFSPersistentVolumeSourcePatch]{ + OutputState: i.ToCephFSPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. type CephFSPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -4106,6 +4599,12 @@ func (o CephFSPersistentVolumeSourcePatchOutput) ToCephFSPersistentVolumeSourceP }).(CephFSPersistentVolumeSourcePatchPtrOutput) } +func (o CephFSPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CephFSPersistentVolumeSourcePatch] { + return pulumix.Output[CephFSPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it func (o CephFSPersistentVolumeSourcePatchOutput) Monitors() pulumi.StringArrayOutput { return o.ApplyT(func(v CephFSPersistentVolumeSourcePatch) []string { return v.Monitors }).(pulumi.StringArrayOutput) @@ -4150,6 +4649,12 @@ func (o CephFSPersistentVolumeSourcePatchPtrOutput) ToCephFSPersistentVolumeSour return o } +func (o CephFSPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CephFSPersistentVolumeSourcePatch] { + return pulumix.Output[*CephFSPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o CephFSPersistentVolumeSourcePatchPtrOutput) Elem() CephFSPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *CephFSPersistentVolumeSourcePatch) CephFSPersistentVolumeSourcePatch { if v != nil { @@ -4275,6 +4780,12 @@ func (i CephFSVolumeSourceArgs) ToCephFSVolumeSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CephFSVolumeSourceOutput) } +func (i CephFSVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[CephFSVolumeSource] { + return pulumix.Output[CephFSVolumeSource]{ + OutputState: i.ToCephFSVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i CephFSVolumeSourceArgs) ToCephFSVolumeSourcePtrOutput() CephFSVolumeSourcePtrOutput { return i.ToCephFSVolumeSourcePtrOutputWithContext(context.Background()) } @@ -4316,6 +4827,12 @@ func (i *cephFSVolumeSourcePtrType) ToCephFSVolumeSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CephFSVolumeSourcePtrOutput) } +func (i *cephFSVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*CephFSVolumeSource] { + return pulumix.Output[*CephFSVolumeSource]{ + OutputState: i.ToCephFSVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. type CephFSVolumeSourceOutput struct{ *pulumi.OutputState } @@ -4341,6 +4858,12 @@ func (o CephFSVolumeSourceOutput) ToCephFSVolumeSourcePtrOutputWithContext(ctx c }).(CephFSVolumeSourcePtrOutput) } +func (o CephFSVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[CephFSVolumeSource] { + return pulumix.Output[CephFSVolumeSource]{ + OutputState: o.OutputState, + } +} + // monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it func (o CephFSVolumeSourceOutput) Monitors() pulumi.StringArrayOutput { return o.ApplyT(func(v CephFSVolumeSource) []string { return v.Monitors }).(pulumi.StringArrayOutput) @@ -4385,6 +4908,12 @@ func (o CephFSVolumeSourcePtrOutput) ToCephFSVolumeSourcePtrOutputWithContext(ct return o } +func (o CephFSVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CephFSVolumeSource] { + return pulumix.Output[*CephFSVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o CephFSVolumeSourcePtrOutput) Elem() CephFSVolumeSourceOutput { return o.ApplyT(func(v *CephFSVolumeSource) CephFSVolumeSource { if v != nil { @@ -4510,6 +5039,12 @@ func (i CephFSVolumeSourcePatchArgs) ToCephFSVolumeSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(CephFSVolumeSourcePatchOutput) } +func (i CephFSVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CephFSVolumeSourcePatch] { + return pulumix.Output[CephFSVolumeSourcePatch]{ + OutputState: i.ToCephFSVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i CephFSVolumeSourcePatchArgs) ToCephFSVolumeSourcePatchPtrOutput() CephFSVolumeSourcePatchPtrOutput { return i.ToCephFSVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -4551,6 +5086,12 @@ func (i *cephFSVolumeSourcePatchPtrType) ToCephFSVolumeSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(CephFSVolumeSourcePatchPtrOutput) } +func (i *cephFSVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CephFSVolumeSourcePatch] { + return pulumix.Output[*CephFSVolumeSourcePatch]{ + OutputState: i.ToCephFSVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. type CephFSVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -4576,6 +5117,12 @@ func (o CephFSVolumeSourcePatchOutput) ToCephFSVolumeSourcePatchPtrOutputWithCon }).(CephFSVolumeSourcePatchPtrOutput) } +func (o CephFSVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CephFSVolumeSourcePatch] { + return pulumix.Output[CephFSVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it func (o CephFSVolumeSourcePatchOutput) Monitors() pulumi.StringArrayOutput { return o.ApplyT(func(v CephFSVolumeSourcePatch) []string { return v.Monitors }).(pulumi.StringArrayOutput) @@ -4620,6 +5167,12 @@ func (o CephFSVolumeSourcePatchPtrOutput) ToCephFSVolumeSourcePatchPtrOutputWith return o } +func (o CephFSVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CephFSVolumeSourcePatch] { + return pulumix.Output[*CephFSVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o CephFSVolumeSourcePatchPtrOutput) Elem() CephFSVolumeSourcePatchOutput { return o.ApplyT(func(v *CephFSVolumeSourcePatch) CephFSVolumeSourcePatch { if v != nil { @@ -4737,6 +5290,12 @@ func (i CinderPersistentVolumeSourceArgs) ToCinderPersistentVolumeSourceOutputWi return pulumi.ToOutputWithContext(ctx, i).(CinderPersistentVolumeSourceOutput) } +func (i CinderPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[CinderPersistentVolumeSource] { + return pulumix.Output[CinderPersistentVolumeSource]{ + OutputState: i.ToCinderPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i CinderPersistentVolumeSourceArgs) ToCinderPersistentVolumeSourcePtrOutput() CinderPersistentVolumeSourcePtrOutput { return i.ToCinderPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -4778,6 +5337,12 @@ func (i *cinderPersistentVolumeSourcePtrType) ToCinderPersistentVolumeSourcePtrO return pulumi.ToOutputWithContext(ctx, i).(CinderPersistentVolumeSourcePtrOutput) } +func (i *cinderPersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*CinderPersistentVolumeSource] { + return pulumix.Output[*CinderPersistentVolumeSource]{ + OutputState: i.ToCinderPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. type CinderPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -4803,6 +5368,12 @@ func (o CinderPersistentVolumeSourceOutput) ToCinderPersistentVolumeSourcePtrOut }).(CinderPersistentVolumeSourcePtrOutput) } +func (o CinderPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[CinderPersistentVolumeSource] { + return pulumix.Output[CinderPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md func (o CinderPersistentVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v CinderPersistentVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -4837,6 +5408,12 @@ func (o CinderPersistentVolumeSourcePtrOutput) ToCinderPersistentVolumeSourcePtr return o } +func (o CinderPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CinderPersistentVolumeSource] { + return pulumix.Output[*CinderPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o CinderPersistentVolumeSourcePtrOutput) Elem() CinderPersistentVolumeSourceOutput { return o.ApplyT(func(v *CinderPersistentVolumeSource) CinderPersistentVolumeSource { if v != nil { @@ -4934,6 +5511,12 @@ func (i CinderPersistentVolumeSourcePatchArgs) ToCinderPersistentVolumeSourcePat return pulumi.ToOutputWithContext(ctx, i).(CinderPersistentVolumeSourcePatchOutput) } +func (i CinderPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CinderPersistentVolumeSourcePatch] { + return pulumix.Output[CinderPersistentVolumeSourcePatch]{ + OutputState: i.ToCinderPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i CinderPersistentVolumeSourcePatchArgs) ToCinderPersistentVolumeSourcePatchPtrOutput() CinderPersistentVolumeSourcePatchPtrOutput { return i.ToCinderPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -4975,6 +5558,12 @@ func (i *cinderPersistentVolumeSourcePatchPtrType) ToCinderPersistentVolumeSourc return pulumi.ToOutputWithContext(ctx, i).(CinderPersistentVolumeSourcePatchPtrOutput) } +func (i *cinderPersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CinderPersistentVolumeSourcePatch] { + return pulumix.Output[*CinderPersistentVolumeSourcePatch]{ + OutputState: i.ToCinderPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. type CinderPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -5000,6 +5589,12 @@ func (o CinderPersistentVolumeSourcePatchOutput) ToCinderPersistentVolumeSourceP }).(CinderPersistentVolumeSourcePatchPtrOutput) } +func (o CinderPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CinderPersistentVolumeSourcePatch] { + return pulumix.Output[CinderPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md func (o CinderPersistentVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v CinderPersistentVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -5034,6 +5629,12 @@ func (o CinderPersistentVolumeSourcePatchPtrOutput) ToCinderPersistentVolumeSour return o } +func (o CinderPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CinderPersistentVolumeSourcePatch] { + return pulumix.Output[*CinderPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o CinderPersistentVolumeSourcePatchPtrOutput) Elem() CinderPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *CinderPersistentVolumeSourcePatch) CinderPersistentVolumeSourcePatch { if v != nil { @@ -5131,6 +5732,12 @@ func (i CinderVolumeSourceArgs) ToCinderVolumeSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CinderVolumeSourceOutput) } +func (i CinderVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[CinderVolumeSource] { + return pulumix.Output[CinderVolumeSource]{ + OutputState: i.ToCinderVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i CinderVolumeSourceArgs) ToCinderVolumeSourcePtrOutput() CinderVolumeSourcePtrOutput { return i.ToCinderVolumeSourcePtrOutputWithContext(context.Background()) } @@ -5172,6 +5779,12 @@ func (i *cinderVolumeSourcePtrType) ToCinderVolumeSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CinderVolumeSourcePtrOutput) } +func (i *cinderVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*CinderVolumeSource] { + return pulumix.Output[*CinderVolumeSource]{ + OutputState: i.ToCinderVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. type CinderVolumeSourceOutput struct{ *pulumi.OutputState } @@ -5197,6 +5810,12 @@ func (o CinderVolumeSourceOutput) ToCinderVolumeSourcePtrOutputWithContext(ctx c }).(CinderVolumeSourcePtrOutput) } +func (o CinderVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[CinderVolumeSource] { + return pulumix.Output[CinderVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md func (o CinderVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v CinderVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -5231,6 +5850,12 @@ func (o CinderVolumeSourcePtrOutput) ToCinderVolumeSourcePtrOutputWithContext(ct return o } +func (o CinderVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CinderVolumeSource] { + return pulumix.Output[*CinderVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o CinderVolumeSourcePtrOutput) Elem() CinderVolumeSourceOutput { return o.ApplyT(func(v *CinderVolumeSource) CinderVolumeSource { if v != nil { @@ -5328,6 +5953,12 @@ func (i CinderVolumeSourcePatchArgs) ToCinderVolumeSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(CinderVolumeSourcePatchOutput) } +func (i CinderVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[CinderVolumeSourcePatch] { + return pulumix.Output[CinderVolumeSourcePatch]{ + OutputState: i.ToCinderVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i CinderVolumeSourcePatchArgs) ToCinderVolumeSourcePatchPtrOutput() CinderVolumeSourcePatchPtrOutput { return i.ToCinderVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -5369,6 +6000,12 @@ func (i *cinderVolumeSourcePatchPtrType) ToCinderVolumeSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(CinderVolumeSourcePatchPtrOutput) } +func (i *cinderVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CinderVolumeSourcePatch] { + return pulumix.Output[*CinderVolumeSourcePatch]{ + OutputState: i.ToCinderVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. type CinderVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -5394,6 +6031,12 @@ func (o CinderVolumeSourcePatchOutput) ToCinderVolumeSourcePatchPtrOutputWithCon }).(CinderVolumeSourcePatchPtrOutput) } +func (o CinderVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[CinderVolumeSourcePatch] { + return pulumix.Output[CinderVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md func (o CinderVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v CinderVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -5428,6 +6071,12 @@ func (o CinderVolumeSourcePatchPtrOutput) ToCinderVolumeSourcePatchPtrOutputWith return o } +func (o CinderVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CinderVolumeSourcePatch] { + return pulumix.Output[*CinderVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o CinderVolumeSourcePatchPtrOutput) Elem() CinderVolumeSourcePatchOutput { return o.ApplyT(func(v *CinderVolumeSourcePatch) CinderVolumeSourcePatch { if v != nil { @@ -5529,6 +6178,12 @@ func (i ClaimSourceArgs) ToClaimSourceOutputWithContext(ctx context.Context) Cla return pulumi.ToOutputWithContext(ctx, i).(ClaimSourceOutput) } +func (i ClaimSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ClaimSource] { + return pulumix.Output[ClaimSource]{ + OutputState: i.ToClaimSourceOutputWithContext(ctx).OutputState, + } +} + func (i ClaimSourceArgs) ToClaimSourcePtrOutput() ClaimSourcePtrOutput { return i.ToClaimSourcePtrOutputWithContext(context.Background()) } @@ -5570,6 +6225,12 @@ func (i *claimSourcePtrType) ToClaimSourcePtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ClaimSourcePtrOutput) } +func (i *claimSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ClaimSource] { + return pulumix.Output[*ClaimSource]{ + OutputState: i.ToClaimSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ClaimSource describes a reference to a ResourceClaim. // // Exactly one of these fields should be set. Consumers of this type must treat an empty object as if it has an unknown value. @@ -5597,6 +6258,12 @@ func (o ClaimSourceOutput) ToClaimSourcePtrOutputWithContext(ctx context.Context }).(ClaimSourcePtrOutput) } +func (o ClaimSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ClaimSource] { + return pulumix.Output[ClaimSource]{ + OutputState: o.OutputState, + } +} + // ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod. func (o ClaimSourceOutput) ResourceClaimName() pulumi.StringPtrOutput { return o.ApplyT(func(v ClaimSource) *string { return v.ResourceClaimName }).(pulumi.StringPtrOutput) @@ -5625,6 +6292,12 @@ func (o ClaimSourcePtrOutput) ToClaimSourcePtrOutputWithContext(ctx context.Cont return o } +func (o ClaimSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClaimSource] { + return pulumix.Output[*ClaimSource]{ + OutputState: o.OutputState, + } +} + func (o ClaimSourcePtrOutput) Elem() ClaimSourceOutput { return o.ApplyT(func(v *ClaimSource) ClaimSource { if v != nil { @@ -5710,6 +6383,12 @@ func (i ClaimSourcePatchArgs) ToClaimSourcePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ClaimSourcePatchOutput) } +func (i ClaimSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ClaimSourcePatch] { + return pulumix.Output[ClaimSourcePatch]{ + OutputState: i.ToClaimSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ClaimSourcePatchArgs) ToClaimSourcePatchPtrOutput() ClaimSourcePatchPtrOutput { return i.ToClaimSourcePatchPtrOutputWithContext(context.Background()) } @@ -5751,6 +6430,12 @@ func (i *claimSourcePatchPtrType) ToClaimSourcePatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ClaimSourcePatchPtrOutput) } +func (i *claimSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ClaimSourcePatch] { + return pulumix.Output[*ClaimSourcePatch]{ + OutputState: i.ToClaimSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ClaimSource describes a reference to a ResourceClaim. // // Exactly one of these fields should be set. Consumers of this type must treat an empty object as if it has an unknown value. @@ -5778,6 +6463,12 @@ func (o ClaimSourcePatchOutput) ToClaimSourcePatchPtrOutputWithContext(ctx conte }).(ClaimSourcePatchPtrOutput) } +func (o ClaimSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ClaimSourcePatch] { + return pulumix.Output[ClaimSourcePatch]{ + OutputState: o.OutputState, + } +} + // ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod. func (o ClaimSourcePatchOutput) ResourceClaimName() pulumi.StringPtrOutput { return o.ApplyT(func(v ClaimSourcePatch) *string { return v.ResourceClaimName }).(pulumi.StringPtrOutput) @@ -5806,6 +6497,12 @@ func (o ClaimSourcePatchPtrOutput) ToClaimSourcePatchPtrOutputWithContext(ctx co return o } +func (o ClaimSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClaimSourcePatch] { + return pulumix.Output[*ClaimSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ClaimSourcePatchPtrOutput) Elem() ClaimSourcePatchOutput { return o.ApplyT(func(v *ClaimSourcePatch) ClaimSourcePatch { if v != nil { @@ -5875,6 +6572,12 @@ func (i ClientIPConfigArgs) ToClientIPConfigOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ClientIPConfigOutput) } +func (i ClientIPConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ClientIPConfig] { + return pulumix.Output[ClientIPConfig]{ + OutputState: i.ToClientIPConfigOutputWithContext(ctx).OutputState, + } +} + func (i ClientIPConfigArgs) ToClientIPConfigPtrOutput() ClientIPConfigPtrOutput { return i.ToClientIPConfigPtrOutputWithContext(context.Background()) } @@ -5916,6 +6619,12 @@ func (i *clientIPConfigPtrType) ToClientIPConfigPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ClientIPConfigPtrOutput) } +func (i *clientIPConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ClientIPConfig] { + return pulumix.Output[*ClientIPConfig]{ + OutputState: i.ToClientIPConfigPtrOutputWithContext(ctx).OutputState, + } +} + // ClientIPConfig represents the configurations of Client IP based session affinity. type ClientIPConfigOutput struct{ *pulumi.OutputState } @@ -5941,6 +6650,12 @@ func (o ClientIPConfigOutput) ToClientIPConfigPtrOutputWithContext(ctx context.C }).(ClientIPConfigPtrOutput) } +func (o ClientIPConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ClientIPConfig] { + return pulumix.Output[ClientIPConfig]{ + OutputState: o.OutputState, + } +} + // timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == "ClientIP". Default value is 10800(for 3 hours). func (o ClientIPConfigOutput) TimeoutSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ClientIPConfig) *int { return v.TimeoutSeconds }).(pulumi.IntPtrOutput) @@ -5960,6 +6675,12 @@ func (o ClientIPConfigPtrOutput) ToClientIPConfigPtrOutputWithContext(ctx contex return o } +func (o ClientIPConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClientIPConfig] { + return pulumix.Output[*ClientIPConfig]{ + OutputState: o.OutputState, + } +} + func (o ClientIPConfigPtrOutput) Elem() ClientIPConfigOutput { return o.ApplyT(func(v *ClientIPConfig) ClientIPConfig { if v != nil { @@ -6015,6 +6736,12 @@ func (i ClientIPConfigPatchArgs) ToClientIPConfigPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClientIPConfigPatchOutput) } +func (i ClientIPConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ClientIPConfigPatch] { + return pulumix.Output[ClientIPConfigPatch]{ + OutputState: i.ToClientIPConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i ClientIPConfigPatchArgs) ToClientIPConfigPatchPtrOutput() ClientIPConfigPatchPtrOutput { return i.ToClientIPConfigPatchPtrOutputWithContext(context.Background()) } @@ -6056,6 +6783,12 @@ func (i *clientIPConfigPatchPtrType) ToClientIPConfigPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ClientIPConfigPatchPtrOutput) } +func (i *clientIPConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ClientIPConfigPatch] { + return pulumix.Output[*ClientIPConfigPatch]{ + OutputState: i.ToClientIPConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ClientIPConfig represents the configurations of Client IP based session affinity. type ClientIPConfigPatchOutput struct{ *pulumi.OutputState } @@ -6081,6 +6814,12 @@ func (o ClientIPConfigPatchOutput) ToClientIPConfigPatchPtrOutputWithContext(ctx }).(ClientIPConfigPatchPtrOutput) } +func (o ClientIPConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ClientIPConfigPatch] { + return pulumix.Output[ClientIPConfigPatch]{ + OutputState: o.OutputState, + } +} + // timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == "ClientIP". Default value is 10800(for 3 hours). func (o ClientIPConfigPatchOutput) TimeoutSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ClientIPConfigPatch) *int { return v.TimeoutSeconds }).(pulumi.IntPtrOutput) @@ -6100,6 +6839,12 @@ func (o ClientIPConfigPatchPtrOutput) ToClientIPConfigPatchPtrOutputWithContext( return o } +func (o ClientIPConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClientIPConfigPatch] { + return pulumix.Output[*ClientIPConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o ClientIPConfigPatchPtrOutput) Elem() ClientIPConfigPatchOutput { return o.ApplyT(func(v *ClientIPConfigPatch) ClientIPConfigPatch { if v != nil { @@ -6167,6 +6912,12 @@ func (i ComponentConditionArgs) ToComponentConditionOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ComponentConditionOutput) } +func (i ComponentConditionArgs) ToOutput(ctx context.Context) pulumix.Output[ComponentCondition] { + return pulumix.Output[ComponentCondition]{ + OutputState: i.ToComponentConditionOutputWithContext(ctx).OutputState, + } +} + // ComponentConditionArrayInput is an input type that accepts ComponentConditionArray and ComponentConditionArrayOutput values. // You can construct a concrete instance of `ComponentConditionArrayInput` via: // @@ -6192,6 +6943,12 @@ func (i ComponentConditionArray) ToComponentConditionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ComponentConditionArrayOutput) } +func (i ComponentConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]ComponentCondition] { + return pulumix.Output[[]ComponentCondition]{ + OutputState: i.ToComponentConditionArrayOutputWithContext(ctx).OutputState, + } +} + // Information about the condition of a component. type ComponentConditionOutput struct{ *pulumi.OutputState } @@ -6207,6 +6964,12 @@ func (o ComponentConditionOutput) ToComponentConditionOutputWithContext(ctx cont return o } +func (o ComponentConditionOutput) ToOutput(ctx context.Context) pulumix.Output[ComponentCondition] { + return pulumix.Output[ComponentCondition]{ + OutputState: o.OutputState, + } +} + // Condition error code for a component. For example, a health check error code. func (o ComponentConditionOutput) Error() pulumi.StringPtrOutput { return o.ApplyT(func(v ComponentCondition) *string { return v.Error }).(pulumi.StringPtrOutput) @@ -6241,6 +7004,12 @@ func (o ComponentConditionArrayOutput) ToComponentConditionArrayOutputWithContex return o } +func (o ComponentConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ComponentCondition] { + return pulumix.Output[[]ComponentCondition]{ + OutputState: o.OutputState, + } +} + func (o ComponentConditionArrayOutput) Index(i pulumi.IntInput) ComponentConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ComponentCondition { return vs[0].([]ComponentCondition)[vs[1].(int)] @@ -6294,6 +7063,12 @@ func (i ComponentConditionPatchArgs) ToComponentConditionPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ComponentConditionPatchOutput) } +func (i ComponentConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ComponentConditionPatch] { + return pulumix.Output[ComponentConditionPatch]{ + OutputState: i.ToComponentConditionPatchOutputWithContext(ctx).OutputState, + } +} + // ComponentConditionPatchArrayInput is an input type that accepts ComponentConditionPatchArray and ComponentConditionPatchArrayOutput values. // You can construct a concrete instance of `ComponentConditionPatchArrayInput` via: // @@ -6319,6 +7094,12 @@ func (i ComponentConditionPatchArray) ToComponentConditionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ComponentConditionPatchArrayOutput) } +func (i ComponentConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ComponentConditionPatch] { + return pulumix.Output[[]ComponentConditionPatch]{ + OutputState: i.ToComponentConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Information about the condition of a component. type ComponentConditionPatchOutput struct{ *pulumi.OutputState } @@ -6334,6 +7115,12 @@ func (o ComponentConditionPatchOutput) ToComponentConditionPatchOutputWithContex return o } +func (o ComponentConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ComponentConditionPatch] { + return pulumix.Output[ComponentConditionPatch]{ + OutputState: o.OutputState, + } +} + // Condition error code for a component. For example, a health check error code. func (o ComponentConditionPatchOutput) Error() pulumi.StringPtrOutput { return o.ApplyT(func(v ComponentConditionPatch) *string { return v.Error }).(pulumi.StringPtrOutput) @@ -6368,6 +7155,12 @@ func (o ComponentConditionPatchArrayOutput) ToComponentConditionPatchArrayOutput return o } +func (o ComponentConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ComponentConditionPatch] { + return pulumix.Output[[]ComponentConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o ComponentConditionPatchArrayOutput) Index(i pulumi.IntInput) ComponentConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ComponentConditionPatch { return vs[0].([]ComponentConditionPatch)[vs[1].(int)] @@ -6421,6 +7214,12 @@ func (i ComponentStatusArgs) ToComponentStatusOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ComponentStatusOutput) } +func (i ComponentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ComponentStatus] { + return pulumix.Output[ComponentStatus]{ + OutputState: i.ToComponentStatusOutputWithContext(ctx).OutputState, + } +} + // ComponentStatusArrayInput is an input type that accepts ComponentStatusArray and ComponentStatusArrayOutput values. // You can construct a concrete instance of `ComponentStatusArrayInput` via: // @@ -6446,6 +7245,12 @@ func (i ComponentStatusArray) ToComponentStatusArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ComponentStatusArrayOutput) } +func (i ComponentStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]ComponentStatus] { + return pulumix.Output[[]ComponentStatus]{ + OutputState: i.ToComponentStatusArrayOutputWithContext(ctx).OutputState, + } +} + // ComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+ type ComponentStatusOutput struct{ *pulumi.OutputState } @@ -6461,6 +7266,12 @@ func (o ComponentStatusOutput) ToComponentStatusOutputWithContext(ctx context.Co return o } +func (o ComponentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ComponentStatus] { + return pulumix.Output[ComponentStatus]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ComponentStatusOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ComponentStatus) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6495,6 +7306,12 @@ func (o ComponentStatusArrayOutput) ToComponentStatusArrayOutputWithContext(ctx return o } +func (o ComponentStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ComponentStatus] { + return pulumix.Output[[]ComponentStatus]{ + OutputState: o.OutputState, + } +} + func (o ComponentStatusArrayOutput) Index(i pulumi.IntInput) ComponentStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ComponentStatus { return vs[0].([]ComponentStatus)[vs[1].(int)] @@ -6548,6 +7365,12 @@ func (i ComponentStatusListArgs) ToComponentStatusListOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ComponentStatusListOutput) } +func (i ComponentStatusListArgs) ToOutput(ctx context.Context) pulumix.Output[ComponentStatusList] { + return pulumix.Output[ComponentStatusList]{ + OutputState: i.ToComponentStatusListOutputWithContext(ctx).OutputState, + } +} + // Status of all the conditions for the component as a list of ComponentStatus objects. Deprecated: This API is deprecated in v1.19+ type ComponentStatusListOutput struct{ *pulumi.OutputState } @@ -6563,6 +7386,12 @@ func (o ComponentStatusListOutput) ToComponentStatusListOutputWithContext(ctx co return o } +func (o ComponentStatusListOutput) ToOutput(ctx context.Context) pulumix.Output[ComponentStatusList] { + return pulumix.Output[ComponentStatusList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ComponentStatusListOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ComponentStatusList) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6630,6 +7459,12 @@ func (i ComponentStatusPatchArgs) ToComponentStatusPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ComponentStatusPatchOutput) } +func (i ComponentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ComponentStatusPatch] { + return pulumix.Output[ComponentStatusPatch]{ + OutputState: i.ToComponentStatusPatchOutputWithContext(ctx).OutputState, + } +} + // ComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+ type ComponentStatusPatchOutput struct{ *pulumi.OutputState } @@ -6645,6 +7480,12 @@ func (o ComponentStatusPatchOutput) ToComponentStatusPatchOutputWithContext(ctx return o } +func (o ComponentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ComponentStatusPatch] { + return pulumix.Output[ComponentStatusPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ComponentStatusPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ComponentStatusPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6720,6 +7561,12 @@ func (i ConfigMapTypeArgs) ToConfigMapTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ConfigMapTypeOutput) } +func (i ConfigMapTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapType] { + return pulumix.Output[ConfigMapType]{ + OutputState: i.ToConfigMapTypeOutputWithContext(ctx).OutputState, + } +} + // ConfigMapTypeArrayInput is an input type that accepts ConfigMapTypeArray and ConfigMapTypeArrayOutput values. // You can construct a concrete instance of `ConfigMapTypeArrayInput` via: // @@ -6745,6 +7592,12 @@ func (i ConfigMapTypeArray) ToConfigMapTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ConfigMapTypeArrayOutput) } +func (i ConfigMapTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ConfigMapType] { + return pulumix.Output[[]ConfigMapType]{ + OutputState: i.ToConfigMapTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ConfigMap holds configuration data for pods to consume. type ConfigMapTypeOutput struct{ *pulumi.OutputState } @@ -6760,6 +7613,12 @@ func (o ConfigMapTypeOutput) ToConfigMapTypeOutputWithContext(ctx context.Contex return o } +func (o ConfigMapTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapType] { + return pulumix.Output[ConfigMapType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ConfigMapTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6804,6 +7663,12 @@ func (o ConfigMapTypeArrayOutput) ToConfigMapTypeArrayOutputWithContext(ctx cont return o } +func (o ConfigMapTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ConfigMapType] { + return pulumix.Output[[]ConfigMapType]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapTypeArrayOutput) Index(i pulumi.IntInput) ConfigMapTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConfigMapType { return vs[0].([]ConfigMapType)[vs[1].(int)] @@ -6853,6 +7718,12 @@ func (i ConfigMapEnvSourceArgs) ToConfigMapEnvSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ConfigMapEnvSourceOutput) } +func (i ConfigMapEnvSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapEnvSource] { + return pulumix.Output[ConfigMapEnvSource]{ + OutputState: i.ToConfigMapEnvSourceOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapEnvSourceArgs) ToConfigMapEnvSourcePtrOutput() ConfigMapEnvSourcePtrOutput { return i.ToConfigMapEnvSourcePtrOutputWithContext(context.Background()) } @@ -6894,6 +7765,12 @@ func (i *configMapEnvSourcePtrType) ToConfigMapEnvSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ConfigMapEnvSourcePtrOutput) } +func (i *configMapEnvSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapEnvSource] { + return pulumix.Output[*ConfigMapEnvSource]{ + OutputState: i.ToConfigMapEnvSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ConfigMapEnvSource selects a ConfigMap to populate the environment variables with. // // The contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables. @@ -6921,6 +7798,12 @@ func (o ConfigMapEnvSourceOutput) ToConfigMapEnvSourcePtrOutputWithContext(ctx c }).(ConfigMapEnvSourcePtrOutput) } +func (o ConfigMapEnvSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapEnvSource] { + return pulumix.Output[ConfigMapEnvSource]{ + OutputState: o.OutputState, + } +} + // Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names func (o ConfigMapEnvSourceOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapEnvSource) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -6945,6 +7828,12 @@ func (o ConfigMapEnvSourcePtrOutput) ToConfigMapEnvSourcePtrOutputWithContext(ct return o } +func (o ConfigMapEnvSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapEnvSource] { + return pulumix.Output[*ConfigMapEnvSource]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapEnvSourcePtrOutput) Elem() ConfigMapEnvSourceOutput { return o.ApplyT(func(v *ConfigMapEnvSource) ConfigMapEnvSource { if v != nil { @@ -7018,6 +7907,12 @@ func (i ConfigMapEnvSourcePatchArgs) ToConfigMapEnvSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ConfigMapEnvSourcePatchOutput) } +func (i ConfigMapEnvSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapEnvSourcePatch] { + return pulumix.Output[ConfigMapEnvSourcePatch]{ + OutputState: i.ToConfigMapEnvSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapEnvSourcePatchArgs) ToConfigMapEnvSourcePatchPtrOutput() ConfigMapEnvSourcePatchPtrOutput { return i.ToConfigMapEnvSourcePatchPtrOutputWithContext(context.Background()) } @@ -7059,6 +7954,12 @@ func (i *configMapEnvSourcePatchPtrType) ToConfigMapEnvSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ConfigMapEnvSourcePatchPtrOutput) } +func (i *configMapEnvSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapEnvSourcePatch] { + return pulumix.Output[*ConfigMapEnvSourcePatch]{ + OutputState: i.ToConfigMapEnvSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ConfigMapEnvSource selects a ConfigMap to populate the environment variables with. // // The contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables. @@ -7086,6 +7987,12 @@ func (o ConfigMapEnvSourcePatchOutput) ToConfigMapEnvSourcePatchPtrOutputWithCon }).(ConfigMapEnvSourcePatchPtrOutput) } +func (o ConfigMapEnvSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapEnvSourcePatch] { + return pulumix.Output[ConfigMapEnvSourcePatch]{ + OutputState: o.OutputState, + } +} + // Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names func (o ConfigMapEnvSourcePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapEnvSourcePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -7110,6 +8017,12 @@ func (o ConfigMapEnvSourcePatchPtrOutput) ToConfigMapEnvSourcePatchPtrOutputWith return o } +func (o ConfigMapEnvSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapEnvSourcePatch] { + return pulumix.Output[*ConfigMapEnvSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapEnvSourcePatchPtrOutput) Elem() ConfigMapEnvSourcePatchOutput { return o.ApplyT(func(v *ConfigMapEnvSourcePatch) ConfigMapEnvSourcePatch { if v != nil { @@ -7183,6 +8096,12 @@ func (i ConfigMapKeySelectorArgs) ToConfigMapKeySelectorOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ConfigMapKeySelectorOutput) } +func (i ConfigMapKeySelectorArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapKeySelector] { + return pulumix.Output[ConfigMapKeySelector]{ + OutputState: i.ToConfigMapKeySelectorOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapKeySelectorArgs) ToConfigMapKeySelectorPtrOutput() ConfigMapKeySelectorPtrOutput { return i.ToConfigMapKeySelectorPtrOutputWithContext(context.Background()) } @@ -7224,6 +8143,12 @@ func (i *configMapKeySelectorPtrType) ToConfigMapKeySelectorPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ConfigMapKeySelectorPtrOutput) } +func (i *configMapKeySelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapKeySelector] { + return pulumix.Output[*ConfigMapKeySelector]{ + OutputState: i.ToConfigMapKeySelectorPtrOutputWithContext(ctx).OutputState, + } +} + // Selects a key from a ConfigMap. type ConfigMapKeySelectorOutput struct{ *pulumi.OutputState } @@ -7249,6 +8174,12 @@ func (o ConfigMapKeySelectorOutput) ToConfigMapKeySelectorPtrOutputWithContext(c }).(ConfigMapKeySelectorPtrOutput) } +func (o ConfigMapKeySelectorOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapKeySelector] { + return pulumix.Output[ConfigMapKeySelector]{ + OutputState: o.OutputState, + } +} + // The key to select. func (o ConfigMapKeySelectorOutput) Key() pulumi.StringOutput { return o.ApplyT(func(v ConfigMapKeySelector) string { return v.Key }).(pulumi.StringOutput) @@ -7278,6 +8209,12 @@ func (o ConfigMapKeySelectorPtrOutput) ToConfigMapKeySelectorPtrOutputWithContex return o } +func (o ConfigMapKeySelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapKeySelector] { + return pulumix.Output[*ConfigMapKeySelector]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapKeySelectorPtrOutput) Elem() ConfigMapKeySelectorOutput { return o.ApplyT(func(v *ConfigMapKeySelector) ConfigMapKeySelector { if v != nil { @@ -7361,6 +8298,12 @@ func (i ConfigMapKeySelectorPatchArgs) ToConfigMapKeySelectorPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ConfigMapKeySelectorPatchOutput) } +func (i ConfigMapKeySelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapKeySelectorPatch] { + return pulumix.Output[ConfigMapKeySelectorPatch]{ + OutputState: i.ToConfigMapKeySelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapKeySelectorPatchArgs) ToConfigMapKeySelectorPatchPtrOutput() ConfigMapKeySelectorPatchPtrOutput { return i.ToConfigMapKeySelectorPatchPtrOutputWithContext(context.Background()) } @@ -7402,6 +8345,12 @@ func (i *configMapKeySelectorPatchPtrType) ToConfigMapKeySelectorPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ConfigMapKeySelectorPatchPtrOutput) } +func (i *configMapKeySelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapKeySelectorPatch] { + return pulumix.Output[*ConfigMapKeySelectorPatch]{ + OutputState: i.ToConfigMapKeySelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Selects a key from a ConfigMap. type ConfigMapKeySelectorPatchOutput struct{ *pulumi.OutputState } @@ -7427,6 +8376,12 @@ func (o ConfigMapKeySelectorPatchOutput) ToConfigMapKeySelectorPatchPtrOutputWit }).(ConfigMapKeySelectorPatchPtrOutput) } +func (o ConfigMapKeySelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapKeySelectorPatch] { + return pulumix.Output[ConfigMapKeySelectorPatch]{ + OutputState: o.OutputState, + } +} + // The key to select. func (o ConfigMapKeySelectorPatchOutput) Key() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapKeySelectorPatch) *string { return v.Key }).(pulumi.StringPtrOutput) @@ -7456,6 +8411,12 @@ func (o ConfigMapKeySelectorPatchPtrOutput) ToConfigMapKeySelectorPatchPtrOutput return o } +func (o ConfigMapKeySelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapKeySelectorPatch] { + return pulumix.Output[*ConfigMapKeySelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapKeySelectorPatchPtrOutput) Elem() ConfigMapKeySelectorPatchOutput { return o.ApplyT(func(v *ConfigMapKeySelectorPatch) ConfigMapKeySelectorPatch { if v != nil { @@ -7543,6 +8504,12 @@ func (i ConfigMapListTypeArgs) ToConfigMapListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ConfigMapListTypeOutput) } +func (i ConfigMapListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapListType] { + return pulumix.Output[ConfigMapListType]{ + OutputState: i.ToConfigMapListTypeOutputWithContext(ctx).OutputState, + } +} + // ConfigMapList is a resource containing a list of ConfigMap objects. type ConfigMapListTypeOutput struct{ *pulumi.OutputState } @@ -7558,6 +8525,12 @@ func (o ConfigMapListTypeOutput) ToConfigMapListTypeOutputWithContext(ctx contex return o } +func (o ConfigMapListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapListType] { + return pulumix.Output[ConfigMapListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ConfigMapListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7629,6 +8602,12 @@ func (i ConfigMapNodeConfigSourceArgs) ToConfigMapNodeConfigSourceOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ConfigMapNodeConfigSourceOutput) } +func (i ConfigMapNodeConfigSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapNodeConfigSource] { + return pulumix.Output[ConfigMapNodeConfigSource]{ + OutputState: i.ToConfigMapNodeConfigSourceOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapNodeConfigSourceArgs) ToConfigMapNodeConfigSourcePtrOutput() ConfigMapNodeConfigSourcePtrOutput { return i.ToConfigMapNodeConfigSourcePtrOutputWithContext(context.Background()) } @@ -7670,6 +8649,12 @@ func (i *configMapNodeConfigSourcePtrType) ToConfigMapNodeConfigSourcePtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ConfigMapNodeConfigSourcePtrOutput) } +func (i *configMapNodeConfigSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapNodeConfigSource] { + return pulumix.Output[*ConfigMapNodeConfigSource]{ + OutputState: i.ToConfigMapNodeConfigSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration type ConfigMapNodeConfigSourceOutput struct{ *pulumi.OutputState } @@ -7695,6 +8680,12 @@ func (o ConfigMapNodeConfigSourceOutput) ToConfigMapNodeConfigSourcePtrOutputWit }).(ConfigMapNodeConfigSourcePtrOutput) } +func (o ConfigMapNodeConfigSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapNodeConfigSource] { + return pulumix.Output[ConfigMapNodeConfigSource]{ + OutputState: o.OutputState, + } +} + // KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases. func (o ConfigMapNodeConfigSourceOutput) KubeletConfigKey() pulumi.StringOutput { return o.ApplyT(func(v ConfigMapNodeConfigSource) string { return v.KubeletConfigKey }).(pulumi.StringOutput) @@ -7734,6 +8725,12 @@ func (o ConfigMapNodeConfigSourcePtrOutput) ToConfigMapNodeConfigSourcePtrOutput return o } +func (o ConfigMapNodeConfigSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapNodeConfigSource] { + return pulumix.Output[*ConfigMapNodeConfigSource]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapNodeConfigSourcePtrOutput) Elem() ConfigMapNodeConfigSourceOutput { return o.ApplyT(func(v *ConfigMapNodeConfigSource) ConfigMapNodeConfigSource { if v != nil { @@ -7845,6 +8842,12 @@ func (i ConfigMapNodeConfigSourcePatchArgs) ToConfigMapNodeConfigSourcePatchOutp return pulumi.ToOutputWithContext(ctx, i).(ConfigMapNodeConfigSourcePatchOutput) } +func (i ConfigMapNodeConfigSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapNodeConfigSourcePatch] { + return pulumix.Output[ConfigMapNodeConfigSourcePatch]{ + OutputState: i.ToConfigMapNodeConfigSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapNodeConfigSourcePatchArgs) ToConfigMapNodeConfigSourcePatchPtrOutput() ConfigMapNodeConfigSourcePatchPtrOutput { return i.ToConfigMapNodeConfigSourcePatchPtrOutputWithContext(context.Background()) } @@ -7886,6 +8889,12 @@ func (i *configMapNodeConfigSourcePatchPtrType) ToConfigMapNodeConfigSourcePatch return pulumi.ToOutputWithContext(ctx, i).(ConfigMapNodeConfigSourcePatchPtrOutput) } +func (i *configMapNodeConfigSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapNodeConfigSourcePatch] { + return pulumix.Output[*ConfigMapNodeConfigSourcePatch]{ + OutputState: i.ToConfigMapNodeConfigSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration type ConfigMapNodeConfigSourcePatchOutput struct{ *pulumi.OutputState } @@ -7911,6 +8920,12 @@ func (o ConfigMapNodeConfigSourcePatchOutput) ToConfigMapNodeConfigSourcePatchPt }).(ConfigMapNodeConfigSourcePatchPtrOutput) } +func (o ConfigMapNodeConfigSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapNodeConfigSourcePatch] { + return pulumix.Output[ConfigMapNodeConfigSourcePatch]{ + OutputState: o.OutputState, + } +} + // KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases. func (o ConfigMapNodeConfigSourcePatchOutput) KubeletConfigKey() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapNodeConfigSourcePatch) *string { return v.KubeletConfigKey }).(pulumi.StringPtrOutput) @@ -7950,6 +8965,12 @@ func (o ConfigMapNodeConfigSourcePatchPtrOutput) ToConfigMapNodeConfigSourcePatc return o } +func (o ConfigMapNodeConfigSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapNodeConfigSourcePatch] { + return pulumix.Output[*ConfigMapNodeConfigSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapNodeConfigSourcePatchPtrOutput) Elem() ConfigMapNodeConfigSourcePatchOutput { return o.ApplyT(func(v *ConfigMapNodeConfigSourcePatch) ConfigMapNodeConfigSourcePatch { if v != nil { @@ -8065,6 +9086,12 @@ func (i ConfigMapPatchTypeArgs) ToConfigMapPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ConfigMapPatchTypeOutput) } +func (i ConfigMapPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapPatchType] { + return pulumix.Output[ConfigMapPatchType]{ + OutputState: i.ToConfigMapPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ConfigMap holds configuration data for pods to consume. type ConfigMapPatchTypeOutput struct{ *pulumi.OutputState } @@ -8080,6 +9107,12 @@ func (o ConfigMapPatchTypeOutput) ToConfigMapPatchTypeOutputWithContext(ctx cont return o } +func (o ConfigMapPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapPatchType] { + return pulumix.Output[ConfigMapPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ConfigMapPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ConfigMapPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -8157,6 +9190,12 @@ func (i ConfigMapProjectionArgs) ToConfigMapProjectionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ConfigMapProjectionOutput) } +func (i ConfigMapProjectionArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapProjection] { + return pulumix.Output[ConfigMapProjection]{ + OutputState: i.ToConfigMapProjectionOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapProjectionArgs) ToConfigMapProjectionPtrOutput() ConfigMapProjectionPtrOutput { return i.ToConfigMapProjectionPtrOutputWithContext(context.Background()) } @@ -8198,6 +9237,12 @@ func (i *configMapProjectionPtrType) ToConfigMapProjectionPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ConfigMapProjectionPtrOutput) } +func (i *configMapProjectionPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapProjection] { + return pulumix.Output[*ConfigMapProjection]{ + OutputState: i.ToConfigMapProjectionPtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a ConfigMap into a projected volume. // // The contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode. @@ -8225,6 +9270,12 @@ func (o ConfigMapProjectionOutput) ToConfigMapProjectionPtrOutputWithContext(ctx }).(ConfigMapProjectionPtrOutput) } +func (o ConfigMapProjectionOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapProjection] { + return pulumix.Output[ConfigMapProjection]{ + OutputState: o.OutputState, + } +} + // items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. func (o ConfigMapProjectionOutput) Items() KeyToPathArrayOutput { return o.ApplyT(func(v ConfigMapProjection) []KeyToPath { return v.Items }).(KeyToPathArrayOutput) @@ -8254,6 +9305,12 @@ func (o ConfigMapProjectionPtrOutput) ToConfigMapProjectionPtrOutputWithContext( return o } +func (o ConfigMapProjectionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapProjection] { + return pulumix.Output[*ConfigMapProjection]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapProjectionPtrOutput) Elem() ConfigMapProjectionOutput { return o.ApplyT(func(v *ConfigMapProjection) ConfigMapProjection { if v != nil { @@ -8341,6 +9398,12 @@ func (i ConfigMapProjectionPatchArgs) ToConfigMapProjectionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ConfigMapProjectionPatchOutput) } +func (i ConfigMapProjectionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapProjectionPatch] { + return pulumix.Output[ConfigMapProjectionPatch]{ + OutputState: i.ToConfigMapProjectionPatchOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapProjectionPatchArgs) ToConfigMapProjectionPatchPtrOutput() ConfigMapProjectionPatchPtrOutput { return i.ToConfigMapProjectionPatchPtrOutputWithContext(context.Background()) } @@ -8382,6 +9445,12 @@ func (i *configMapProjectionPatchPtrType) ToConfigMapProjectionPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ConfigMapProjectionPatchPtrOutput) } +func (i *configMapProjectionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapProjectionPatch] { + return pulumix.Output[*ConfigMapProjectionPatch]{ + OutputState: i.ToConfigMapProjectionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a ConfigMap into a projected volume. // // The contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode. @@ -8409,6 +9478,12 @@ func (o ConfigMapProjectionPatchOutput) ToConfigMapProjectionPatchPtrOutputWithC }).(ConfigMapProjectionPatchPtrOutput) } +func (o ConfigMapProjectionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapProjectionPatch] { + return pulumix.Output[ConfigMapProjectionPatch]{ + OutputState: o.OutputState, + } +} + // items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. func (o ConfigMapProjectionPatchOutput) Items() KeyToPathPatchArrayOutput { return o.ApplyT(func(v ConfigMapProjectionPatch) []KeyToPathPatch { return v.Items }).(KeyToPathPatchArrayOutput) @@ -8438,6 +9513,12 @@ func (o ConfigMapProjectionPatchPtrOutput) ToConfigMapProjectionPatchPtrOutputWi return o } +func (o ConfigMapProjectionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapProjectionPatch] { + return pulumix.Output[*ConfigMapProjectionPatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapProjectionPatchPtrOutput) Elem() ConfigMapProjectionPatchOutput { return o.ApplyT(func(v *ConfigMapProjectionPatch) ConfigMapProjectionPatch { if v != nil { @@ -8529,6 +9610,12 @@ func (i ConfigMapVolumeSourceArgs) ToConfigMapVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ConfigMapVolumeSourceOutput) } +func (i ConfigMapVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapVolumeSource] { + return pulumix.Output[ConfigMapVolumeSource]{ + OutputState: i.ToConfigMapVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapVolumeSourceArgs) ToConfigMapVolumeSourcePtrOutput() ConfigMapVolumeSourcePtrOutput { return i.ToConfigMapVolumeSourcePtrOutputWithContext(context.Background()) } @@ -8570,6 +9657,12 @@ func (i *configMapVolumeSourcePtrType) ToConfigMapVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ConfigMapVolumeSourcePtrOutput) } +func (i *configMapVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapVolumeSource] { + return pulumix.Output[*ConfigMapVolumeSource]{ + OutputState: i.ToConfigMapVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a ConfigMap into a volume. // // The contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling. @@ -8597,6 +9690,12 @@ func (o ConfigMapVolumeSourceOutput) ToConfigMapVolumeSourcePtrOutputWithContext }).(ConfigMapVolumeSourcePtrOutput) } +func (o ConfigMapVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapVolumeSource] { + return pulumix.Output[ConfigMapVolumeSource]{ + OutputState: o.OutputState, + } +} + // defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o ConfigMapVolumeSourceOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v ConfigMapVolumeSource) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -8631,6 +9730,12 @@ func (o ConfigMapVolumeSourcePtrOutput) ToConfigMapVolumeSourcePtrOutputWithCont return o } +func (o ConfigMapVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapVolumeSource] { + return pulumix.Output[*ConfigMapVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapVolumeSourcePtrOutput) Elem() ConfigMapVolumeSourceOutput { return o.ApplyT(func(v *ConfigMapVolumeSource) ConfigMapVolumeSource { if v != nil { @@ -8732,6 +9837,12 @@ func (i ConfigMapVolumeSourcePatchArgs) ToConfigMapVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ConfigMapVolumeSourcePatchOutput) } +func (i ConfigMapVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ConfigMapVolumeSourcePatch] { + return pulumix.Output[ConfigMapVolumeSourcePatch]{ + OutputState: i.ToConfigMapVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ConfigMapVolumeSourcePatchArgs) ToConfigMapVolumeSourcePatchPtrOutput() ConfigMapVolumeSourcePatchPtrOutput { return i.ToConfigMapVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -8773,6 +9884,12 @@ func (i *configMapVolumeSourcePatchPtrType) ToConfigMapVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ConfigMapVolumeSourcePatchPtrOutput) } +func (i *configMapVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapVolumeSourcePatch] { + return pulumix.Output[*ConfigMapVolumeSourcePatch]{ + OutputState: i.ToConfigMapVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a ConfigMap into a volume. // // The contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling. @@ -8800,6 +9917,12 @@ func (o ConfigMapVolumeSourcePatchOutput) ToConfigMapVolumeSourcePatchPtrOutputW }).(ConfigMapVolumeSourcePatchPtrOutput) } +func (o ConfigMapVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ConfigMapVolumeSourcePatch] { + return pulumix.Output[ConfigMapVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o ConfigMapVolumeSourcePatchOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v ConfigMapVolumeSourcePatch) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -8834,6 +9957,12 @@ func (o ConfigMapVolumeSourcePatchPtrOutput) ToConfigMapVolumeSourcePatchPtrOutp return o } +func (o ConfigMapVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ConfigMapVolumeSourcePatch] { + return pulumix.Output[*ConfigMapVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ConfigMapVolumeSourcePatchPtrOutput) Elem() ConfigMapVolumeSourcePatchOutput { return o.ApplyT(func(v *ConfigMapVolumeSourcePatch) ConfigMapVolumeSourcePatch { if v != nil { @@ -9011,6 +10140,12 @@ func (i ContainerArgs) ToContainerOutputWithContext(ctx context.Context) Contain return pulumi.ToOutputWithContext(ctx, i).(ContainerOutput) } +func (i ContainerArgs) ToOutput(ctx context.Context) pulumix.Output[Container] { + return pulumix.Output[Container]{ + OutputState: i.ToContainerOutputWithContext(ctx).OutputState, + } +} + // ContainerArrayInput is an input type that accepts ContainerArray and ContainerArrayOutput values. // You can construct a concrete instance of `ContainerArrayInput` via: // @@ -9036,6 +10171,12 @@ func (i ContainerArray) ToContainerArrayOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ContainerArrayOutput) } +func (i ContainerArray) ToOutput(ctx context.Context) pulumix.Output[[]Container] { + return pulumix.Output[[]Container]{ + OutputState: i.ToContainerArrayOutputWithContext(ctx).OutputState, + } +} + // A single application container that you want to run within a pod. type ContainerOutput struct{ *pulumi.OutputState } @@ -9051,6 +10192,12 @@ func (o ContainerOutput) ToContainerOutputWithContext(ctx context.Context) Conta return o } +func (o ContainerOutput) ToOutput(ctx context.Context) pulumix.Output[Container] { + return pulumix.Output[Container]{ + OutputState: o.OutputState, + } +} + // Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell func (o ContainerOutput) Args() pulumi.StringArrayOutput { return o.ApplyT(func(v Container) []string { return v.Args }).(pulumi.StringArrayOutput) @@ -9185,6 +10332,12 @@ func (o ContainerArrayOutput) ToContainerArrayOutputWithContext(ctx context.Cont return o } +func (o ContainerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Container] { + return pulumix.Output[[]Container]{ + OutputState: o.OutputState, + } +} + func (o ContainerArrayOutput) Index(i pulumi.IntInput) ContainerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Container { return vs[0].([]Container)[vs[1].(int)] @@ -9230,6 +10383,12 @@ func (i ContainerImageArgs) ToContainerImageOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ContainerImageOutput) } +func (i ContainerImageArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerImage] { + return pulumix.Output[ContainerImage]{ + OutputState: i.ToContainerImageOutputWithContext(ctx).OutputState, + } +} + // ContainerImageArrayInput is an input type that accepts ContainerImageArray and ContainerImageArrayOutput values. // You can construct a concrete instance of `ContainerImageArrayInput` via: // @@ -9255,6 +10414,12 @@ func (i ContainerImageArray) ToContainerImageArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ContainerImageArrayOutput) } +func (i ContainerImageArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerImage] { + return pulumix.Output[[]ContainerImage]{ + OutputState: i.ToContainerImageArrayOutputWithContext(ctx).OutputState, + } +} + // Describe a container image type ContainerImageOutput struct{ *pulumi.OutputState } @@ -9270,6 +10435,12 @@ func (o ContainerImageOutput) ToContainerImageOutputWithContext(ctx context.Cont return o } +func (o ContainerImageOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerImage] { + return pulumix.Output[ContainerImage]{ + OutputState: o.OutputState, + } +} + // Names by which this image is known. e.g. ["kubernetes.example/hyperkube:v1.0.7", "cloud-vendor.registry.example/cloud-vendor/hyperkube:v1.0.7"] func (o ContainerImageOutput) Names() pulumi.StringArrayOutput { return o.ApplyT(func(v ContainerImage) []string { return v.Names }).(pulumi.StringArrayOutput) @@ -9294,6 +10465,12 @@ func (o ContainerImageArrayOutput) ToContainerImageArrayOutputWithContext(ctx co return o } +func (o ContainerImageArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerImage] { + return pulumix.Output[[]ContainerImage]{ + OutputState: o.OutputState, + } +} + func (o ContainerImageArrayOutput) Index(i pulumi.IntInput) ContainerImageOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerImage { return vs[0].([]ContainerImage)[vs[1].(int)] @@ -9339,6 +10516,12 @@ func (i ContainerImagePatchArgs) ToContainerImagePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ContainerImagePatchOutput) } +func (i ContainerImagePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerImagePatch] { + return pulumix.Output[ContainerImagePatch]{ + OutputState: i.ToContainerImagePatchOutputWithContext(ctx).OutputState, + } +} + // ContainerImagePatchArrayInput is an input type that accepts ContainerImagePatchArray and ContainerImagePatchArrayOutput values. // You can construct a concrete instance of `ContainerImagePatchArrayInput` via: // @@ -9364,6 +10547,12 @@ func (i ContainerImagePatchArray) ToContainerImagePatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ContainerImagePatchArrayOutput) } +func (i ContainerImagePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerImagePatch] { + return pulumix.Output[[]ContainerImagePatch]{ + OutputState: i.ToContainerImagePatchArrayOutputWithContext(ctx).OutputState, + } +} + // Describe a container image type ContainerImagePatchOutput struct{ *pulumi.OutputState } @@ -9379,6 +10568,12 @@ func (o ContainerImagePatchOutput) ToContainerImagePatchOutputWithContext(ctx co return o } +func (o ContainerImagePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerImagePatch] { + return pulumix.Output[ContainerImagePatch]{ + OutputState: o.OutputState, + } +} + // Names by which this image is known. e.g. ["kubernetes.example/hyperkube:v1.0.7", "cloud-vendor.registry.example/cloud-vendor/hyperkube:v1.0.7"] func (o ContainerImagePatchOutput) Names() pulumi.StringArrayOutput { return o.ApplyT(func(v ContainerImagePatch) []string { return v.Names }).(pulumi.StringArrayOutput) @@ -9403,6 +10598,12 @@ func (o ContainerImagePatchArrayOutput) ToContainerImagePatchArrayOutputWithCont return o } +func (o ContainerImagePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerImagePatch] { + return pulumix.Output[[]ContainerImagePatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerImagePatchArrayOutput) Index(i pulumi.IntInput) ContainerImagePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerImagePatch { return vs[0].([]ContainerImagePatch)[vs[1].(int)] @@ -9536,6 +10737,12 @@ func (i ContainerPatchArgs) ToContainerPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ContainerPatchOutput) } +func (i ContainerPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerPatch] { + return pulumix.Output[ContainerPatch]{ + OutputState: i.ToContainerPatchOutputWithContext(ctx).OutputState, + } +} + // ContainerPatchArrayInput is an input type that accepts ContainerPatchArray and ContainerPatchArrayOutput values. // You can construct a concrete instance of `ContainerPatchArrayInput` via: // @@ -9561,6 +10768,12 @@ func (i ContainerPatchArray) ToContainerPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ContainerPatchArrayOutput) } +func (i ContainerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerPatch] { + return pulumix.Output[[]ContainerPatch]{ + OutputState: i.ToContainerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A single application container that you want to run within a pod. type ContainerPatchOutput struct{ *pulumi.OutputState } @@ -9576,6 +10789,12 @@ func (o ContainerPatchOutput) ToContainerPatchOutputWithContext(ctx context.Cont return o } +func (o ContainerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerPatch] { + return pulumix.Output[ContainerPatch]{ + OutputState: o.OutputState, + } +} + // Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell func (o ContainerPatchOutput) Args() pulumi.StringArrayOutput { return o.ApplyT(func(v ContainerPatch) []string { return v.Args }).(pulumi.StringArrayOutput) @@ -9710,6 +10929,12 @@ func (o ContainerPatchArrayOutput) ToContainerPatchArrayOutputWithContext(ctx co return o } +func (o ContainerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerPatch] { + return pulumix.Output[[]ContainerPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerPatchArrayOutput) Index(i pulumi.IntInput) ContainerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerPatch { return vs[0].([]ContainerPatch)[vs[1].(int)] @@ -9767,6 +10992,12 @@ func (i ContainerPortArgs) ToContainerPortOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ContainerPortOutput) } +func (i ContainerPortArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerPort] { + return pulumix.Output[ContainerPort]{ + OutputState: i.ToContainerPortOutputWithContext(ctx).OutputState, + } +} + // ContainerPortArrayInput is an input type that accepts ContainerPortArray and ContainerPortArrayOutput values. // You can construct a concrete instance of `ContainerPortArrayInput` via: // @@ -9792,6 +11023,12 @@ func (i ContainerPortArray) ToContainerPortArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ContainerPortArrayOutput) } +func (i ContainerPortArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerPort] { + return pulumix.Output[[]ContainerPort]{ + OutputState: i.ToContainerPortArrayOutputWithContext(ctx).OutputState, + } +} + // ContainerPort represents a network port in a single container. type ContainerPortOutput struct{ *pulumi.OutputState } @@ -9807,6 +11044,12 @@ func (o ContainerPortOutput) ToContainerPortOutputWithContext(ctx context.Contex return o } +func (o ContainerPortOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerPort] { + return pulumix.Output[ContainerPort]{ + OutputState: o.OutputState, + } +} + // Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. func (o ContainerPortOutput) ContainerPort() pulumi.IntOutput { return o.ApplyT(func(v ContainerPort) int { return v.ContainerPort }).(pulumi.IntOutput) @@ -9846,6 +11089,12 @@ func (o ContainerPortArrayOutput) ToContainerPortArrayOutputWithContext(ctx cont return o } +func (o ContainerPortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerPort] { + return pulumix.Output[[]ContainerPort]{ + OutputState: o.OutputState, + } +} + func (o ContainerPortArrayOutput) Index(i pulumi.IntInput) ContainerPortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerPort { return vs[0].([]ContainerPort)[vs[1].(int)] @@ -9903,6 +11152,12 @@ func (i ContainerPortPatchArgs) ToContainerPortPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ContainerPortPatchOutput) } +func (i ContainerPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerPortPatch] { + return pulumix.Output[ContainerPortPatch]{ + OutputState: i.ToContainerPortPatchOutputWithContext(ctx).OutputState, + } +} + // ContainerPortPatchArrayInput is an input type that accepts ContainerPortPatchArray and ContainerPortPatchArrayOutput values. // You can construct a concrete instance of `ContainerPortPatchArrayInput` via: // @@ -9928,6 +11183,12 @@ func (i ContainerPortPatchArray) ToContainerPortPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ContainerPortPatchArrayOutput) } +func (i ContainerPortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerPortPatch] { + return pulumix.Output[[]ContainerPortPatch]{ + OutputState: i.ToContainerPortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ContainerPort represents a network port in a single container. type ContainerPortPatchOutput struct{ *pulumi.OutputState } @@ -9943,6 +11204,12 @@ func (o ContainerPortPatchOutput) ToContainerPortPatchOutputWithContext(ctx cont return o } +func (o ContainerPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerPortPatch] { + return pulumix.Output[ContainerPortPatch]{ + OutputState: o.OutputState, + } +} + // Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. func (o ContainerPortPatchOutput) ContainerPort() pulumi.IntPtrOutput { return o.ApplyT(func(v ContainerPortPatch) *int { return v.ContainerPort }).(pulumi.IntPtrOutput) @@ -9982,6 +11249,12 @@ func (o ContainerPortPatchArrayOutput) ToContainerPortPatchArrayOutputWithContex return o } +func (o ContainerPortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerPortPatch] { + return pulumix.Output[[]ContainerPortPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerPortPatchArrayOutput) Index(i pulumi.IntInput) ContainerPortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerPortPatch { return vs[0].([]ContainerPortPatch)[vs[1].(int)] @@ -10027,6 +11300,12 @@ func (i ContainerResizePolicyArgs) ToContainerResizePolicyOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ContainerResizePolicyOutput) } +func (i ContainerResizePolicyArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResizePolicy] { + return pulumix.Output[ContainerResizePolicy]{ + OutputState: i.ToContainerResizePolicyOutputWithContext(ctx).OutputState, + } +} + // ContainerResizePolicyArrayInput is an input type that accepts ContainerResizePolicyArray and ContainerResizePolicyArrayOutput values. // You can construct a concrete instance of `ContainerResizePolicyArrayInput` via: // @@ -10052,6 +11331,12 @@ func (i ContainerResizePolicyArray) ToContainerResizePolicyArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ContainerResizePolicyArrayOutput) } +func (i ContainerResizePolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerResizePolicy] { + return pulumix.Output[[]ContainerResizePolicy]{ + OutputState: i.ToContainerResizePolicyArrayOutputWithContext(ctx).OutputState, + } +} + // ContainerResizePolicy represents resource resize policy for the container. type ContainerResizePolicyOutput struct{ *pulumi.OutputState } @@ -10067,6 +11352,12 @@ func (o ContainerResizePolicyOutput) ToContainerResizePolicyOutputWithContext(ct return o } +func (o ContainerResizePolicyOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResizePolicy] { + return pulumix.Output[ContainerResizePolicy]{ + OutputState: o.OutputState, + } +} + // Name of the resource to which this resource resize policy applies. Supported values: cpu, memory. func (o ContainerResizePolicyOutput) ResourceName() pulumi.StringOutput { return o.ApplyT(func(v ContainerResizePolicy) string { return v.ResourceName }).(pulumi.StringOutput) @@ -10091,6 +11382,12 @@ func (o ContainerResizePolicyArrayOutput) ToContainerResizePolicyArrayOutputWith return o } +func (o ContainerResizePolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerResizePolicy] { + return pulumix.Output[[]ContainerResizePolicy]{ + OutputState: o.OutputState, + } +} + func (o ContainerResizePolicyArrayOutput) Index(i pulumi.IntInput) ContainerResizePolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerResizePolicy { return vs[0].([]ContainerResizePolicy)[vs[1].(int)] @@ -10136,6 +11433,12 @@ func (i ContainerResizePolicyPatchArgs) ToContainerResizePolicyPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ContainerResizePolicyPatchOutput) } +func (i ContainerResizePolicyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerResizePolicyPatch] { + return pulumix.Output[ContainerResizePolicyPatch]{ + OutputState: i.ToContainerResizePolicyPatchOutputWithContext(ctx).OutputState, + } +} + // ContainerResizePolicyPatchArrayInput is an input type that accepts ContainerResizePolicyPatchArray and ContainerResizePolicyPatchArrayOutput values. // You can construct a concrete instance of `ContainerResizePolicyPatchArrayInput` via: // @@ -10161,6 +11464,12 @@ func (i ContainerResizePolicyPatchArray) ToContainerResizePolicyPatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerResizePolicyPatchArrayOutput) } +func (i ContainerResizePolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerResizePolicyPatch] { + return pulumix.Output[[]ContainerResizePolicyPatch]{ + OutputState: i.ToContainerResizePolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ContainerResizePolicy represents resource resize policy for the container. type ContainerResizePolicyPatchOutput struct{ *pulumi.OutputState } @@ -10176,6 +11485,12 @@ func (o ContainerResizePolicyPatchOutput) ToContainerResizePolicyPatchOutputWith return o } +func (o ContainerResizePolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerResizePolicyPatch] { + return pulumix.Output[ContainerResizePolicyPatch]{ + OutputState: o.OutputState, + } +} + // Name of the resource to which this resource resize policy applies. Supported values: cpu, memory. func (o ContainerResizePolicyPatchOutput) ResourceName() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerResizePolicyPatch) *string { return v.ResourceName }).(pulumi.StringPtrOutput) @@ -10200,6 +11515,12 @@ func (o ContainerResizePolicyPatchArrayOutput) ToContainerResizePolicyPatchArray return o } +func (o ContainerResizePolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerResizePolicyPatch] { + return pulumix.Output[[]ContainerResizePolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerResizePolicyPatchArrayOutput) Index(i pulumi.IntInput) ContainerResizePolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerResizePolicyPatch { return vs[0].([]ContainerResizePolicyPatch)[vs[1].(int)] @@ -10249,6 +11570,12 @@ func (i ContainerStateArgs) ToContainerStateOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ContainerStateOutput) } +func (i ContainerStateArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerState] { + return pulumix.Output[ContainerState]{ + OutputState: i.ToContainerStateOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateArgs) ToContainerStatePtrOutput() ContainerStatePtrOutput { return i.ToContainerStatePtrOutputWithContext(context.Background()) } @@ -10290,6 +11617,12 @@ func (i *containerStatePtrType) ToContainerStatePtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ContainerStatePtrOutput) } +func (i *containerStatePtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerState] { + return pulumix.Output[*ContainerState]{ + OutputState: i.ToContainerStatePtrOutputWithContext(ctx).OutputState, + } +} + // ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting. type ContainerStateOutput struct{ *pulumi.OutputState } @@ -10315,6 +11648,12 @@ func (o ContainerStateOutput) ToContainerStatePtrOutputWithContext(ctx context.C }).(ContainerStatePtrOutput) } +func (o ContainerStateOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerState] { + return pulumix.Output[ContainerState]{ + OutputState: o.OutputState, + } +} + // Details about a running container func (o ContainerStateOutput) Running() ContainerStateRunningPtrOutput { return o.ApplyT(func(v ContainerState) *ContainerStateRunning { return v.Running }).(ContainerStateRunningPtrOutput) @@ -10344,6 +11683,12 @@ func (o ContainerStatePtrOutput) ToContainerStatePtrOutputWithContext(ctx contex return o } +func (o ContainerStatePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerState] { + return pulumix.Output[*ContainerState]{ + OutputState: o.OutputState, + } +} + func (o ContainerStatePtrOutput) Elem() ContainerStateOutput { return o.ApplyT(func(v *ContainerState) ContainerState { if v != nil { @@ -10427,6 +11772,12 @@ func (i ContainerStatePatchArgs) ToContainerStatePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ContainerStatePatchOutput) } +func (i ContainerStatePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStatePatch] { + return pulumix.Output[ContainerStatePatch]{ + OutputState: i.ToContainerStatePatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStatePatchArgs) ToContainerStatePatchPtrOutput() ContainerStatePatchPtrOutput { return i.ToContainerStatePatchPtrOutputWithContext(context.Background()) } @@ -10468,6 +11819,12 @@ func (i *containerStatePatchPtrType) ToContainerStatePatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ContainerStatePatchPtrOutput) } +func (i *containerStatePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStatePatch] { + return pulumix.Output[*ContainerStatePatch]{ + OutputState: i.ToContainerStatePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting. type ContainerStatePatchOutput struct{ *pulumi.OutputState } @@ -10493,6 +11850,12 @@ func (o ContainerStatePatchOutput) ToContainerStatePatchPtrOutputWithContext(ctx }).(ContainerStatePatchPtrOutput) } +func (o ContainerStatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStatePatch] { + return pulumix.Output[ContainerStatePatch]{ + OutputState: o.OutputState, + } +} + // Details about a running container func (o ContainerStatePatchOutput) Running() ContainerStateRunningPatchPtrOutput { return o.ApplyT(func(v ContainerStatePatch) *ContainerStateRunningPatch { return v.Running }).(ContainerStateRunningPatchPtrOutput) @@ -10522,6 +11885,12 @@ func (o ContainerStatePatchPtrOutput) ToContainerStatePatchPtrOutputWithContext( return o } +func (o ContainerStatePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStatePatch] { + return pulumix.Output[*ContainerStatePatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerStatePatchPtrOutput) Elem() ContainerStatePatchOutput { return o.ApplyT(func(v *ContainerStatePatch) ContainerStatePatch { if v != nil { @@ -10597,6 +11966,12 @@ func (i ContainerStateRunningArgs) ToContainerStateRunningOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ContainerStateRunningOutput) } +func (i ContainerStateRunningArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStateRunning] { + return pulumix.Output[ContainerStateRunning]{ + OutputState: i.ToContainerStateRunningOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateRunningArgs) ToContainerStateRunningPtrOutput() ContainerStateRunningPtrOutput { return i.ToContainerStateRunningPtrOutputWithContext(context.Background()) } @@ -10638,6 +12013,12 @@ func (i *containerStateRunningPtrType) ToContainerStateRunningPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ContainerStateRunningPtrOutput) } +func (i *containerStateRunningPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateRunning] { + return pulumix.Output[*ContainerStateRunning]{ + OutputState: i.ToContainerStateRunningPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerStateRunning is a running state of a container. type ContainerStateRunningOutput struct{ *pulumi.OutputState } @@ -10663,6 +12044,12 @@ func (o ContainerStateRunningOutput) ToContainerStateRunningPtrOutputWithContext }).(ContainerStateRunningPtrOutput) } +func (o ContainerStateRunningOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStateRunning] { + return pulumix.Output[ContainerStateRunning]{ + OutputState: o.OutputState, + } +} + // Time at which the container was last (re-)started func (o ContainerStateRunningOutput) StartedAt() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerStateRunning) *string { return v.StartedAt }).(pulumi.StringPtrOutput) @@ -10682,6 +12069,12 @@ func (o ContainerStateRunningPtrOutput) ToContainerStateRunningPtrOutputWithCont return o } +func (o ContainerStateRunningPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateRunning] { + return pulumix.Output[*ContainerStateRunning]{ + OutputState: o.OutputState, + } +} + func (o ContainerStateRunningPtrOutput) Elem() ContainerStateRunningOutput { return o.ApplyT(func(v *ContainerStateRunning) ContainerStateRunning { if v != nil { @@ -10737,6 +12130,12 @@ func (i ContainerStateRunningPatchArgs) ToContainerStateRunningPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ContainerStateRunningPatchOutput) } +func (i ContainerStateRunningPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStateRunningPatch] { + return pulumix.Output[ContainerStateRunningPatch]{ + OutputState: i.ToContainerStateRunningPatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateRunningPatchArgs) ToContainerStateRunningPatchPtrOutput() ContainerStateRunningPatchPtrOutput { return i.ToContainerStateRunningPatchPtrOutputWithContext(context.Background()) } @@ -10778,6 +12177,12 @@ func (i *containerStateRunningPatchPtrType) ToContainerStateRunningPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ContainerStateRunningPatchPtrOutput) } +func (i *containerStateRunningPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateRunningPatch] { + return pulumix.Output[*ContainerStateRunningPatch]{ + OutputState: i.ToContainerStateRunningPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerStateRunning is a running state of a container. type ContainerStateRunningPatchOutput struct{ *pulumi.OutputState } @@ -10803,6 +12208,12 @@ func (o ContainerStateRunningPatchOutput) ToContainerStateRunningPatchPtrOutputW }).(ContainerStateRunningPatchPtrOutput) } +func (o ContainerStateRunningPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStateRunningPatch] { + return pulumix.Output[ContainerStateRunningPatch]{ + OutputState: o.OutputState, + } +} + // Time at which the container was last (re-)started func (o ContainerStateRunningPatchOutput) StartedAt() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerStateRunningPatch) *string { return v.StartedAt }).(pulumi.StringPtrOutput) @@ -10822,6 +12233,12 @@ func (o ContainerStateRunningPatchPtrOutput) ToContainerStateRunningPatchPtrOutp return o } +func (o ContainerStateRunningPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateRunningPatch] { + return pulumix.Output[*ContainerStateRunningPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerStateRunningPatchPtrOutput) Elem() ContainerStateRunningPatchOutput { return o.ApplyT(func(v *ContainerStateRunningPatch) ContainerStateRunningPatch { if v != nil { @@ -10901,6 +12318,12 @@ func (i ContainerStateTerminatedArgs) ToContainerStateTerminatedOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ContainerStateTerminatedOutput) } +func (i ContainerStateTerminatedArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStateTerminated] { + return pulumix.Output[ContainerStateTerminated]{ + OutputState: i.ToContainerStateTerminatedOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateTerminatedArgs) ToContainerStateTerminatedPtrOutput() ContainerStateTerminatedPtrOutput { return i.ToContainerStateTerminatedPtrOutputWithContext(context.Background()) } @@ -10942,6 +12365,12 @@ func (i *containerStateTerminatedPtrType) ToContainerStateTerminatedPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ContainerStateTerminatedPtrOutput) } +func (i *containerStateTerminatedPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateTerminated] { + return pulumix.Output[*ContainerStateTerminated]{ + OutputState: i.ToContainerStateTerminatedPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerStateTerminated is a terminated state of a container. type ContainerStateTerminatedOutput struct{ *pulumi.OutputState } @@ -10967,6 +12396,12 @@ func (o ContainerStateTerminatedOutput) ToContainerStateTerminatedPtrOutputWithC }).(ContainerStateTerminatedPtrOutput) } +func (o ContainerStateTerminatedOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStateTerminated] { + return pulumix.Output[ContainerStateTerminated]{ + OutputState: o.OutputState, + } +} + // Container's ID in the format '://' func (o ContainerStateTerminatedOutput) ContainerID() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerStateTerminated) *string { return v.ContainerID }).(pulumi.StringPtrOutput) @@ -11016,6 +12451,12 @@ func (o ContainerStateTerminatedPtrOutput) ToContainerStateTerminatedPtrOutputWi return o } +func (o ContainerStateTerminatedPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateTerminated] { + return pulumix.Output[*ContainerStateTerminated]{ + OutputState: o.OutputState, + } +} + func (o ContainerStateTerminatedPtrOutput) Elem() ContainerStateTerminatedOutput { return o.ApplyT(func(v *ContainerStateTerminated) ContainerStateTerminated { if v != nil { @@ -11155,6 +12596,12 @@ func (i ContainerStateTerminatedPatchArgs) ToContainerStateTerminatedPatchOutput return pulumi.ToOutputWithContext(ctx, i).(ContainerStateTerminatedPatchOutput) } +func (i ContainerStateTerminatedPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStateTerminatedPatch] { + return pulumix.Output[ContainerStateTerminatedPatch]{ + OutputState: i.ToContainerStateTerminatedPatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateTerminatedPatchArgs) ToContainerStateTerminatedPatchPtrOutput() ContainerStateTerminatedPatchPtrOutput { return i.ToContainerStateTerminatedPatchPtrOutputWithContext(context.Background()) } @@ -11196,6 +12643,12 @@ func (i *containerStateTerminatedPatchPtrType) ToContainerStateTerminatedPatchPt return pulumi.ToOutputWithContext(ctx, i).(ContainerStateTerminatedPatchPtrOutput) } +func (i *containerStateTerminatedPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateTerminatedPatch] { + return pulumix.Output[*ContainerStateTerminatedPatch]{ + OutputState: i.ToContainerStateTerminatedPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerStateTerminated is a terminated state of a container. type ContainerStateTerminatedPatchOutput struct{ *pulumi.OutputState } @@ -11221,6 +12674,12 @@ func (o ContainerStateTerminatedPatchOutput) ToContainerStateTerminatedPatchPtrO }).(ContainerStateTerminatedPatchPtrOutput) } +func (o ContainerStateTerminatedPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStateTerminatedPatch] { + return pulumix.Output[ContainerStateTerminatedPatch]{ + OutputState: o.OutputState, + } +} + // Container's ID in the format '://' func (o ContainerStateTerminatedPatchOutput) ContainerID() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerStateTerminatedPatch) *string { return v.ContainerID }).(pulumi.StringPtrOutput) @@ -11270,6 +12729,12 @@ func (o ContainerStateTerminatedPatchPtrOutput) ToContainerStateTerminatedPatchP return o } +func (o ContainerStateTerminatedPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateTerminatedPatch] { + return pulumix.Output[*ContainerStateTerminatedPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerStateTerminatedPatchPtrOutput) Elem() ContainerStateTerminatedPatchOutput { return o.ApplyT(func(v *ContainerStateTerminatedPatch) ContainerStateTerminatedPatch { if v != nil { @@ -11389,6 +12854,12 @@ func (i ContainerStateWaitingArgs) ToContainerStateWaitingOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ContainerStateWaitingOutput) } +func (i ContainerStateWaitingArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStateWaiting] { + return pulumix.Output[ContainerStateWaiting]{ + OutputState: i.ToContainerStateWaitingOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateWaitingArgs) ToContainerStateWaitingPtrOutput() ContainerStateWaitingPtrOutput { return i.ToContainerStateWaitingPtrOutputWithContext(context.Background()) } @@ -11430,6 +12901,12 @@ func (i *containerStateWaitingPtrType) ToContainerStateWaitingPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ContainerStateWaitingPtrOutput) } +func (i *containerStateWaitingPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateWaiting] { + return pulumix.Output[*ContainerStateWaiting]{ + OutputState: i.ToContainerStateWaitingPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerStateWaiting is a waiting state of a container. type ContainerStateWaitingOutput struct{ *pulumi.OutputState } @@ -11455,6 +12932,12 @@ func (o ContainerStateWaitingOutput) ToContainerStateWaitingPtrOutputWithContext }).(ContainerStateWaitingPtrOutput) } +func (o ContainerStateWaitingOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStateWaiting] { + return pulumix.Output[ContainerStateWaiting]{ + OutputState: o.OutputState, + } +} + // Message regarding why the container is not yet running. func (o ContainerStateWaitingOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerStateWaiting) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -11479,6 +12962,12 @@ func (o ContainerStateWaitingPtrOutput) ToContainerStateWaitingPtrOutputWithCont return o } +func (o ContainerStateWaitingPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateWaiting] { + return pulumix.Output[*ContainerStateWaiting]{ + OutputState: o.OutputState, + } +} + func (o ContainerStateWaitingPtrOutput) Elem() ContainerStateWaitingOutput { return o.ApplyT(func(v *ContainerStateWaiting) ContainerStateWaiting { if v != nil { @@ -11548,6 +13037,12 @@ func (i ContainerStateWaitingPatchArgs) ToContainerStateWaitingPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ContainerStateWaitingPatchOutput) } +func (i ContainerStateWaitingPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStateWaitingPatch] { + return pulumix.Output[ContainerStateWaitingPatch]{ + OutputState: i.ToContainerStateWaitingPatchOutputWithContext(ctx).OutputState, + } +} + func (i ContainerStateWaitingPatchArgs) ToContainerStateWaitingPatchPtrOutput() ContainerStateWaitingPatchPtrOutput { return i.ToContainerStateWaitingPatchPtrOutputWithContext(context.Background()) } @@ -11589,6 +13084,12 @@ func (i *containerStateWaitingPatchPtrType) ToContainerStateWaitingPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ContainerStateWaitingPatchPtrOutput) } +func (i *containerStateWaitingPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateWaitingPatch] { + return pulumix.Output[*ContainerStateWaitingPatch]{ + OutputState: i.ToContainerStateWaitingPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ContainerStateWaiting is a waiting state of a container. type ContainerStateWaitingPatchOutput struct{ *pulumi.OutputState } @@ -11614,6 +13115,12 @@ func (o ContainerStateWaitingPatchOutput) ToContainerStateWaitingPatchPtrOutputW }).(ContainerStateWaitingPatchPtrOutput) } +func (o ContainerStateWaitingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStateWaitingPatch] { + return pulumix.Output[ContainerStateWaitingPatch]{ + OutputState: o.OutputState, + } +} + // Message regarding why the container is not yet running. func (o ContainerStateWaitingPatchOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v ContainerStateWaitingPatch) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -11638,6 +13145,12 @@ func (o ContainerStateWaitingPatchPtrOutput) ToContainerStateWaitingPatchPtrOutp return o } +func (o ContainerStateWaitingPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ContainerStateWaitingPatch] { + return pulumix.Output[*ContainerStateWaitingPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerStateWaitingPatchPtrOutput) Elem() ContainerStateWaitingPatchOutput { return o.ApplyT(func(v *ContainerStateWaitingPatch) ContainerStateWaitingPatch { if v != nil { @@ -11747,6 +13260,12 @@ func (i ContainerStatusArgs) ToContainerStatusOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ContainerStatusOutput) } +func (i ContainerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStatus] { + return pulumix.Output[ContainerStatus]{ + OutputState: i.ToContainerStatusOutputWithContext(ctx).OutputState, + } +} + // ContainerStatusArrayInput is an input type that accepts ContainerStatusArray and ContainerStatusArrayOutput values. // You can construct a concrete instance of `ContainerStatusArrayInput` via: // @@ -11772,6 +13291,12 @@ func (i ContainerStatusArray) ToContainerStatusArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ContainerStatusArrayOutput) } +func (i ContainerStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerStatus] { + return pulumix.Output[[]ContainerStatus]{ + OutputState: i.ToContainerStatusArrayOutputWithContext(ctx).OutputState, + } +} + // ContainerStatus contains details for the current status of this container. type ContainerStatusOutput struct{ *pulumi.OutputState } @@ -11787,6 +13312,12 @@ func (o ContainerStatusOutput) ToContainerStatusOutputWithContext(ctx context.Co return o } +func (o ContainerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStatus] { + return pulumix.Output[ContainerStatus]{ + OutputState: o.OutputState, + } +} + // AllocatedResources represents the compute resources allocated for this container by the node. Kubelet sets this value to Container.Resources.Requests upon successful pod admission and after successfully admitting desired pod resize. func (o ContainerStatusOutput) AllocatedResources() pulumi.StringMapOutput { return o.ApplyT(func(v ContainerStatus) map[string]string { return v.AllocatedResources }).(pulumi.StringMapOutput) @@ -11858,6 +13389,12 @@ func (o ContainerStatusArrayOutput) ToContainerStatusArrayOutputWithContext(ctx return o } +func (o ContainerStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerStatus] { + return pulumix.Output[[]ContainerStatus]{ + OutputState: o.OutputState, + } +} + func (o ContainerStatusArrayOutput) Index(i pulumi.IntInput) ContainerStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerStatus { return vs[0].([]ContainerStatus)[vs[1].(int)] @@ -11943,6 +13480,12 @@ func (i ContainerStatusPatchArgs) ToContainerStatusPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ContainerStatusPatchOutput) } +func (i ContainerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ContainerStatusPatch] { + return pulumix.Output[ContainerStatusPatch]{ + OutputState: i.ToContainerStatusPatchOutputWithContext(ctx).OutputState, + } +} + // ContainerStatusPatchArrayInput is an input type that accepts ContainerStatusPatchArray and ContainerStatusPatchArrayOutput values. // You can construct a concrete instance of `ContainerStatusPatchArrayInput` via: // @@ -11968,6 +13511,12 @@ func (i ContainerStatusPatchArray) ToContainerStatusPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ContainerStatusPatchArrayOutput) } +func (i ContainerStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ContainerStatusPatch] { + return pulumix.Output[[]ContainerStatusPatch]{ + OutputState: i.ToContainerStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ContainerStatus contains details for the current status of this container. type ContainerStatusPatchOutput struct{ *pulumi.OutputState } @@ -11983,6 +13532,12 @@ func (o ContainerStatusPatchOutput) ToContainerStatusPatchOutputWithContext(ctx return o } +func (o ContainerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ContainerStatusPatch] { + return pulumix.Output[ContainerStatusPatch]{ + OutputState: o.OutputState, + } +} + // AllocatedResources represents the compute resources allocated for this container by the node. Kubelet sets this value to Container.Resources.Requests upon successful pod admission and after successfully admitting desired pod resize. func (o ContainerStatusPatchOutput) AllocatedResources() pulumi.StringMapOutput { return o.ApplyT(func(v ContainerStatusPatch) map[string]string { return v.AllocatedResources }).(pulumi.StringMapOutput) @@ -12054,6 +13609,12 @@ func (o ContainerStatusPatchArrayOutput) ToContainerStatusPatchArrayOutputWithCo return o } +func (o ContainerStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ContainerStatusPatch] { + return pulumix.Output[[]ContainerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ContainerStatusPatchArrayOutput) Index(i pulumi.IntInput) ContainerStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerStatusPatch { return vs[0].([]ContainerStatusPatch)[vs[1].(int)] @@ -12095,6 +13656,12 @@ func (i DaemonEndpointArgs) ToDaemonEndpointOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DaemonEndpointOutput) } +func (i DaemonEndpointArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonEndpoint] { + return pulumix.Output[DaemonEndpoint]{ + OutputState: i.ToDaemonEndpointOutputWithContext(ctx).OutputState, + } +} + func (i DaemonEndpointArgs) ToDaemonEndpointPtrOutput() DaemonEndpointPtrOutput { return i.ToDaemonEndpointPtrOutputWithContext(context.Background()) } @@ -12136,6 +13703,12 @@ func (i *daemonEndpointPtrType) ToDaemonEndpointPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(DaemonEndpointPtrOutput) } +func (i *daemonEndpointPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonEndpoint] { + return pulumix.Output[*DaemonEndpoint]{ + OutputState: i.ToDaemonEndpointPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonEndpoint contains information about a single Daemon endpoint. type DaemonEndpointOutput struct{ *pulumi.OutputState } @@ -12161,6 +13734,12 @@ func (o DaemonEndpointOutput) ToDaemonEndpointPtrOutputWithContext(ctx context.C }).(DaemonEndpointPtrOutput) } +func (o DaemonEndpointOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonEndpoint] { + return pulumix.Output[DaemonEndpoint]{ + OutputState: o.OutputState, + } +} + // Port number of the given endpoint. func (o DaemonEndpointOutput) Port() pulumi.IntOutput { return o.ApplyT(func(v DaemonEndpoint) int { return v.Port }).(pulumi.IntOutput) @@ -12180,6 +13759,12 @@ func (o DaemonEndpointPtrOutput) ToDaemonEndpointPtrOutputWithContext(ctx contex return o } +func (o DaemonEndpointPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonEndpoint] { + return pulumix.Output[*DaemonEndpoint]{ + OutputState: o.OutputState, + } +} + func (o DaemonEndpointPtrOutput) Elem() DaemonEndpointOutput { return o.ApplyT(func(v *DaemonEndpoint) DaemonEndpoint { if v != nil { @@ -12235,6 +13820,12 @@ func (i DaemonEndpointPatchArgs) ToDaemonEndpointPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DaemonEndpointPatchOutput) } +func (i DaemonEndpointPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonEndpointPatch] { + return pulumix.Output[DaemonEndpointPatch]{ + OutputState: i.ToDaemonEndpointPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonEndpointPatchArgs) ToDaemonEndpointPatchPtrOutput() DaemonEndpointPatchPtrOutput { return i.ToDaemonEndpointPatchPtrOutputWithContext(context.Background()) } @@ -12276,6 +13867,12 @@ func (i *daemonEndpointPatchPtrType) ToDaemonEndpointPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(DaemonEndpointPatchPtrOutput) } +func (i *daemonEndpointPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonEndpointPatch] { + return pulumix.Output[*DaemonEndpointPatch]{ + OutputState: i.ToDaemonEndpointPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonEndpoint contains information about a single Daemon endpoint. type DaemonEndpointPatchOutput struct{ *pulumi.OutputState } @@ -12301,6 +13898,12 @@ func (o DaemonEndpointPatchOutput) ToDaemonEndpointPatchPtrOutputWithContext(ctx }).(DaemonEndpointPatchPtrOutput) } +func (o DaemonEndpointPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonEndpointPatch] { + return pulumix.Output[DaemonEndpointPatch]{ + OutputState: o.OutputState, + } +} + // Port number of the given endpoint. func (o DaemonEndpointPatchOutput) Port() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonEndpointPatch) *int { return v.Port }).(pulumi.IntPtrOutput) @@ -12320,6 +13923,12 @@ func (o DaemonEndpointPatchPtrOutput) ToDaemonEndpointPatchPtrOutputWithContext( return o } +func (o DaemonEndpointPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonEndpointPatch] { + return pulumix.Output[*DaemonEndpointPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonEndpointPatchPtrOutput) Elem() DaemonEndpointPatchOutput { return o.ApplyT(func(v *DaemonEndpointPatch) DaemonEndpointPatch { if v != nil { @@ -12375,6 +13984,12 @@ func (i DownwardAPIProjectionArgs) ToDownwardAPIProjectionOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIProjectionOutput) } +func (i DownwardAPIProjectionArgs) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIProjection] { + return pulumix.Output[DownwardAPIProjection]{ + OutputState: i.ToDownwardAPIProjectionOutputWithContext(ctx).OutputState, + } +} + func (i DownwardAPIProjectionArgs) ToDownwardAPIProjectionPtrOutput() DownwardAPIProjectionPtrOutput { return i.ToDownwardAPIProjectionPtrOutputWithContext(context.Background()) } @@ -12416,6 +14031,12 @@ func (i *downwardAPIProjectionPtrType) ToDownwardAPIProjectionPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIProjectionPtrOutput) } +func (i *downwardAPIProjectionPtrType) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIProjection] { + return pulumix.Output[*DownwardAPIProjection]{ + OutputState: i.ToDownwardAPIProjectionPtrOutputWithContext(ctx).OutputState, + } +} + // Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode. type DownwardAPIProjectionOutput struct{ *pulumi.OutputState } @@ -12441,6 +14062,12 @@ func (o DownwardAPIProjectionOutput) ToDownwardAPIProjectionPtrOutputWithContext }).(DownwardAPIProjectionPtrOutput) } +func (o DownwardAPIProjectionOutput) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIProjection] { + return pulumix.Output[DownwardAPIProjection]{ + OutputState: o.OutputState, + } +} + // Items is a list of DownwardAPIVolume file func (o DownwardAPIProjectionOutput) Items() DownwardAPIVolumeFileArrayOutput { return o.ApplyT(func(v DownwardAPIProjection) []DownwardAPIVolumeFile { return v.Items }).(DownwardAPIVolumeFileArrayOutput) @@ -12460,6 +14087,12 @@ func (o DownwardAPIProjectionPtrOutput) ToDownwardAPIProjectionPtrOutputWithCont return o } +func (o DownwardAPIProjectionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIProjection] { + return pulumix.Output[*DownwardAPIProjection]{ + OutputState: o.OutputState, + } +} + func (o DownwardAPIProjectionPtrOutput) Elem() DownwardAPIProjectionOutput { return o.ApplyT(func(v *DownwardAPIProjection) DownwardAPIProjection { if v != nil { @@ -12515,6 +14148,12 @@ func (i DownwardAPIProjectionPatchArgs) ToDownwardAPIProjectionPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIProjectionPatchOutput) } +func (i DownwardAPIProjectionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIProjectionPatch] { + return pulumix.Output[DownwardAPIProjectionPatch]{ + OutputState: i.ToDownwardAPIProjectionPatchOutputWithContext(ctx).OutputState, + } +} + func (i DownwardAPIProjectionPatchArgs) ToDownwardAPIProjectionPatchPtrOutput() DownwardAPIProjectionPatchPtrOutput { return i.ToDownwardAPIProjectionPatchPtrOutputWithContext(context.Background()) } @@ -12556,6 +14195,12 @@ func (i *downwardAPIProjectionPatchPtrType) ToDownwardAPIProjectionPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIProjectionPatchPtrOutput) } +func (i *downwardAPIProjectionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIProjectionPatch] { + return pulumix.Output[*DownwardAPIProjectionPatch]{ + OutputState: i.ToDownwardAPIProjectionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode. type DownwardAPIProjectionPatchOutput struct{ *pulumi.OutputState } @@ -12581,6 +14226,12 @@ func (o DownwardAPIProjectionPatchOutput) ToDownwardAPIProjectionPatchPtrOutputW }).(DownwardAPIProjectionPatchPtrOutput) } +func (o DownwardAPIProjectionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIProjectionPatch] { + return pulumix.Output[DownwardAPIProjectionPatch]{ + OutputState: o.OutputState, + } +} + // Items is a list of DownwardAPIVolume file func (o DownwardAPIProjectionPatchOutput) Items() DownwardAPIVolumeFilePatchArrayOutput { return o.ApplyT(func(v DownwardAPIProjectionPatch) []DownwardAPIVolumeFilePatch { return v.Items }).(DownwardAPIVolumeFilePatchArrayOutput) @@ -12600,6 +14251,12 @@ func (o DownwardAPIProjectionPatchPtrOutput) ToDownwardAPIProjectionPatchPtrOutp return o } +func (o DownwardAPIProjectionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIProjectionPatch] { + return pulumix.Output[*DownwardAPIProjectionPatch]{ + OutputState: o.OutputState, + } +} + func (o DownwardAPIProjectionPatchPtrOutput) Elem() DownwardAPIProjectionPatchOutput { return o.ApplyT(func(v *DownwardAPIProjectionPatch) DownwardAPIProjectionPatch { if v != nil { @@ -12667,6 +14324,12 @@ func (i DownwardAPIVolumeFileArgs) ToDownwardAPIVolumeFileOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeFileOutput) } +func (i DownwardAPIVolumeFileArgs) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeFile] { + return pulumix.Output[DownwardAPIVolumeFile]{ + OutputState: i.ToDownwardAPIVolumeFileOutputWithContext(ctx).OutputState, + } +} + // DownwardAPIVolumeFileArrayInput is an input type that accepts DownwardAPIVolumeFileArray and DownwardAPIVolumeFileArrayOutput values. // You can construct a concrete instance of `DownwardAPIVolumeFileArrayInput` via: // @@ -12692,6 +14355,12 @@ func (i DownwardAPIVolumeFileArray) ToDownwardAPIVolumeFileArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeFileArrayOutput) } +func (i DownwardAPIVolumeFileArray) ToOutput(ctx context.Context) pulumix.Output[[]DownwardAPIVolumeFile] { + return pulumix.Output[[]DownwardAPIVolumeFile]{ + OutputState: i.ToDownwardAPIVolumeFileArrayOutputWithContext(ctx).OutputState, + } +} + // DownwardAPIVolumeFile represents information to create the file containing the pod field type DownwardAPIVolumeFileOutput struct{ *pulumi.OutputState } @@ -12707,6 +14376,12 @@ func (o DownwardAPIVolumeFileOutput) ToDownwardAPIVolumeFileOutputWithContext(ct return o } +func (o DownwardAPIVolumeFileOutput) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeFile] { + return pulumix.Output[DownwardAPIVolumeFile]{ + OutputState: o.OutputState, + } +} + // Required: Selects a field of the pod: only annotations, labels, name and namespace are supported. func (o DownwardAPIVolumeFileOutput) FieldRef() ObjectFieldSelectorPtrOutput { return o.ApplyT(func(v DownwardAPIVolumeFile) *ObjectFieldSelector { return v.FieldRef }).(ObjectFieldSelectorPtrOutput) @@ -12741,6 +14416,12 @@ func (o DownwardAPIVolumeFileArrayOutput) ToDownwardAPIVolumeFileArrayOutputWith return o } +func (o DownwardAPIVolumeFileArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DownwardAPIVolumeFile] { + return pulumix.Output[[]DownwardAPIVolumeFile]{ + OutputState: o.OutputState, + } +} + func (o DownwardAPIVolumeFileArrayOutput) Index(i pulumi.IntInput) DownwardAPIVolumeFileOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DownwardAPIVolumeFile { return vs[0].([]DownwardAPIVolumeFile)[vs[1].(int)] @@ -12794,6 +14475,12 @@ func (i DownwardAPIVolumeFilePatchArgs) ToDownwardAPIVolumeFilePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeFilePatchOutput) } +func (i DownwardAPIVolumeFilePatchArgs) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeFilePatch] { + return pulumix.Output[DownwardAPIVolumeFilePatch]{ + OutputState: i.ToDownwardAPIVolumeFilePatchOutputWithContext(ctx).OutputState, + } +} + // DownwardAPIVolumeFilePatchArrayInput is an input type that accepts DownwardAPIVolumeFilePatchArray and DownwardAPIVolumeFilePatchArrayOutput values. // You can construct a concrete instance of `DownwardAPIVolumeFilePatchArrayInput` via: // @@ -12819,6 +14506,12 @@ func (i DownwardAPIVolumeFilePatchArray) ToDownwardAPIVolumeFilePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeFilePatchArrayOutput) } +func (i DownwardAPIVolumeFilePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DownwardAPIVolumeFilePatch] { + return pulumix.Output[[]DownwardAPIVolumeFilePatch]{ + OutputState: i.ToDownwardAPIVolumeFilePatchArrayOutputWithContext(ctx).OutputState, + } +} + // DownwardAPIVolumeFile represents information to create the file containing the pod field type DownwardAPIVolumeFilePatchOutput struct{ *pulumi.OutputState } @@ -12834,6 +14527,12 @@ func (o DownwardAPIVolumeFilePatchOutput) ToDownwardAPIVolumeFilePatchOutputWith return o } +func (o DownwardAPIVolumeFilePatchOutput) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeFilePatch] { + return pulumix.Output[DownwardAPIVolumeFilePatch]{ + OutputState: o.OutputState, + } +} + // Required: Selects a field of the pod: only annotations, labels, name and namespace are supported. func (o DownwardAPIVolumeFilePatchOutput) FieldRef() ObjectFieldSelectorPatchPtrOutput { return o.ApplyT(func(v DownwardAPIVolumeFilePatch) *ObjectFieldSelectorPatch { return v.FieldRef }).(ObjectFieldSelectorPatchPtrOutput) @@ -12868,6 +14567,12 @@ func (o DownwardAPIVolumeFilePatchArrayOutput) ToDownwardAPIVolumeFilePatchArray return o } +func (o DownwardAPIVolumeFilePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DownwardAPIVolumeFilePatch] { + return pulumix.Output[[]DownwardAPIVolumeFilePatch]{ + OutputState: o.OutputState, + } +} + func (o DownwardAPIVolumeFilePatchArrayOutput) Index(i pulumi.IntInput) DownwardAPIVolumeFilePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DownwardAPIVolumeFilePatch { return vs[0].([]DownwardAPIVolumeFilePatch)[vs[1].(int)] @@ -12913,6 +14618,12 @@ func (i DownwardAPIVolumeSourceArgs) ToDownwardAPIVolumeSourceOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeSourceOutput) } +func (i DownwardAPIVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeSource] { + return pulumix.Output[DownwardAPIVolumeSource]{ + OutputState: i.ToDownwardAPIVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i DownwardAPIVolumeSourceArgs) ToDownwardAPIVolumeSourcePtrOutput() DownwardAPIVolumeSourcePtrOutput { return i.ToDownwardAPIVolumeSourcePtrOutputWithContext(context.Background()) } @@ -12954,6 +14665,12 @@ func (i *downwardAPIVolumeSourcePtrType) ToDownwardAPIVolumeSourcePtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeSourcePtrOutput) } +func (i *downwardAPIVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIVolumeSource] { + return pulumix.Output[*DownwardAPIVolumeSource]{ + OutputState: i.ToDownwardAPIVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling. type DownwardAPIVolumeSourceOutput struct{ *pulumi.OutputState } @@ -12979,6 +14696,12 @@ func (o DownwardAPIVolumeSourceOutput) ToDownwardAPIVolumeSourcePtrOutputWithCon }).(DownwardAPIVolumeSourcePtrOutput) } +func (o DownwardAPIVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeSource] { + return pulumix.Output[DownwardAPIVolumeSource]{ + OutputState: o.OutputState, + } +} + // Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o DownwardAPIVolumeSourceOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v DownwardAPIVolumeSource) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -13003,6 +14726,12 @@ func (o DownwardAPIVolumeSourcePtrOutput) ToDownwardAPIVolumeSourcePtrOutputWith return o } +func (o DownwardAPIVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIVolumeSource] { + return pulumix.Output[*DownwardAPIVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o DownwardAPIVolumeSourcePtrOutput) Elem() DownwardAPIVolumeSourceOutput { return o.ApplyT(func(v *DownwardAPIVolumeSource) DownwardAPIVolumeSource { if v != nil { @@ -13072,6 +14801,12 @@ func (i DownwardAPIVolumeSourcePatchArgs) ToDownwardAPIVolumeSourcePatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeSourcePatchOutput) } +func (i DownwardAPIVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeSourcePatch] { + return pulumix.Output[DownwardAPIVolumeSourcePatch]{ + OutputState: i.ToDownwardAPIVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i DownwardAPIVolumeSourcePatchArgs) ToDownwardAPIVolumeSourcePatchPtrOutput() DownwardAPIVolumeSourcePatchPtrOutput { return i.ToDownwardAPIVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -13113,6 +14848,12 @@ func (i *downwardAPIVolumeSourcePatchPtrType) ToDownwardAPIVolumeSourcePatchPtrO return pulumi.ToOutputWithContext(ctx, i).(DownwardAPIVolumeSourcePatchPtrOutput) } +func (i *downwardAPIVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIVolumeSourcePatch] { + return pulumix.Output[*DownwardAPIVolumeSourcePatch]{ + OutputState: i.ToDownwardAPIVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling. type DownwardAPIVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -13138,6 +14879,12 @@ func (o DownwardAPIVolumeSourcePatchOutput) ToDownwardAPIVolumeSourcePatchPtrOut }).(DownwardAPIVolumeSourcePatchPtrOutput) } +func (o DownwardAPIVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[DownwardAPIVolumeSourcePatch] { + return pulumix.Output[DownwardAPIVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o DownwardAPIVolumeSourcePatchOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v DownwardAPIVolumeSourcePatch) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -13162,6 +14909,12 @@ func (o DownwardAPIVolumeSourcePatchPtrOutput) ToDownwardAPIVolumeSourcePatchPtr return o } +func (o DownwardAPIVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DownwardAPIVolumeSourcePatch] { + return pulumix.Output[*DownwardAPIVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o DownwardAPIVolumeSourcePatchPtrOutput) Elem() DownwardAPIVolumeSourcePatchOutput { return o.ApplyT(func(v *DownwardAPIVolumeSourcePatch) DownwardAPIVolumeSourcePatch { if v != nil { @@ -13231,6 +14984,12 @@ func (i EmptyDirVolumeSourceArgs) ToEmptyDirVolumeSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EmptyDirVolumeSourceOutput) } +func (i EmptyDirVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[EmptyDirVolumeSource] { + return pulumix.Output[EmptyDirVolumeSource]{ + OutputState: i.ToEmptyDirVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i EmptyDirVolumeSourceArgs) ToEmptyDirVolumeSourcePtrOutput() EmptyDirVolumeSourcePtrOutput { return i.ToEmptyDirVolumeSourcePtrOutputWithContext(context.Background()) } @@ -13272,6 +15031,12 @@ func (i *emptyDirVolumeSourcePtrType) ToEmptyDirVolumeSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(EmptyDirVolumeSourcePtrOutput) } +func (i *emptyDirVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*EmptyDirVolumeSource] { + return pulumix.Output[*EmptyDirVolumeSource]{ + OutputState: i.ToEmptyDirVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling. type EmptyDirVolumeSourceOutput struct{ *pulumi.OutputState } @@ -13297,6 +15062,12 @@ func (o EmptyDirVolumeSourceOutput) ToEmptyDirVolumeSourcePtrOutputWithContext(c }).(EmptyDirVolumeSourcePtrOutput) } +func (o EmptyDirVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[EmptyDirVolumeSource] { + return pulumix.Output[EmptyDirVolumeSource]{ + OutputState: o.OutputState, + } +} + // medium represents what type of storage medium should back this directory. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir func (o EmptyDirVolumeSourceOutput) Medium() pulumi.StringPtrOutput { return o.ApplyT(func(v EmptyDirVolumeSource) *string { return v.Medium }).(pulumi.StringPtrOutput) @@ -13321,6 +15092,12 @@ func (o EmptyDirVolumeSourcePtrOutput) ToEmptyDirVolumeSourcePtrOutputWithContex return o } +func (o EmptyDirVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EmptyDirVolumeSource] { + return pulumix.Output[*EmptyDirVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o EmptyDirVolumeSourcePtrOutput) Elem() EmptyDirVolumeSourceOutput { return o.ApplyT(func(v *EmptyDirVolumeSource) EmptyDirVolumeSource { if v != nil { @@ -13390,6 +15167,12 @@ func (i EmptyDirVolumeSourcePatchArgs) ToEmptyDirVolumeSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(EmptyDirVolumeSourcePatchOutput) } +func (i EmptyDirVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[EmptyDirVolumeSourcePatch] { + return pulumix.Output[EmptyDirVolumeSourcePatch]{ + OutputState: i.ToEmptyDirVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i EmptyDirVolumeSourcePatchArgs) ToEmptyDirVolumeSourcePatchPtrOutput() EmptyDirVolumeSourcePatchPtrOutput { return i.ToEmptyDirVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -13431,6 +15214,12 @@ func (i *emptyDirVolumeSourcePatchPtrType) ToEmptyDirVolumeSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(EmptyDirVolumeSourcePatchPtrOutput) } +func (i *emptyDirVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EmptyDirVolumeSourcePatch] { + return pulumix.Output[*EmptyDirVolumeSourcePatch]{ + OutputState: i.ToEmptyDirVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling. type EmptyDirVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -13456,6 +15245,12 @@ func (o EmptyDirVolumeSourcePatchOutput) ToEmptyDirVolumeSourcePatchPtrOutputWit }).(EmptyDirVolumeSourcePatchPtrOutput) } +func (o EmptyDirVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[EmptyDirVolumeSourcePatch] { + return pulumix.Output[EmptyDirVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // medium represents what type of storage medium should back this directory. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir func (o EmptyDirVolumeSourcePatchOutput) Medium() pulumi.StringPtrOutput { return o.ApplyT(func(v EmptyDirVolumeSourcePatch) *string { return v.Medium }).(pulumi.StringPtrOutput) @@ -13480,6 +15275,12 @@ func (o EmptyDirVolumeSourcePatchPtrOutput) ToEmptyDirVolumeSourcePatchPtrOutput return o } +func (o EmptyDirVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EmptyDirVolumeSourcePatch] { + return pulumix.Output[*EmptyDirVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o EmptyDirVolumeSourcePatchPtrOutput) Elem() EmptyDirVolumeSourcePatchOutput { return o.ApplyT(func(v *EmptyDirVolumeSourcePatch) EmptyDirVolumeSourcePatch { if v != nil { @@ -13557,6 +15358,12 @@ func (i EndpointAddressArgs) ToEndpointAddressOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(EndpointAddressOutput) } +func (i EndpointAddressArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointAddress] { + return pulumix.Output[EndpointAddress]{ + OutputState: i.ToEndpointAddressOutputWithContext(ctx).OutputState, + } +} + // EndpointAddressArrayInput is an input type that accepts EndpointAddressArray and EndpointAddressArrayOutput values. // You can construct a concrete instance of `EndpointAddressArrayInput` via: // @@ -13582,6 +15389,12 @@ func (i EndpointAddressArray) ToEndpointAddressArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointAddressArrayOutput) } +func (i EndpointAddressArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointAddress] { + return pulumix.Output[[]EndpointAddress]{ + OutputState: i.ToEndpointAddressArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointAddress is a tuple that describes single IP address. type EndpointAddressOutput struct{ *pulumi.OutputState } @@ -13597,6 +15410,12 @@ func (o EndpointAddressOutput) ToEndpointAddressOutputWithContext(ctx context.Co return o } +func (o EndpointAddressOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointAddress] { + return pulumix.Output[EndpointAddress]{ + OutputState: o.OutputState, + } +} + // The Hostname of this endpoint func (o EndpointAddressOutput) Hostname() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointAddress) *string { return v.Hostname }).(pulumi.StringPtrOutput) @@ -13631,6 +15450,12 @@ func (o EndpointAddressArrayOutput) ToEndpointAddressArrayOutputWithContext(ctx return o } +func (o EndpointAddressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointAddress] { + return pulumix.Output[[]EndpointAddress]{ + OutputState: o.OutputState, + } +} + func (o EndpointAddressArrayOutput) Index(i pulumi.IntInput) EndpointAddressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointAddress { return vs[0].([]EndpointAddress)[vs[1].(int)] @@ -13684,6 +15509,12 @@ func (i EndpointAddressPatchArgs) ToEndpointAddressPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointAddressPatchOutput) } +func (i EndpointAddressPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointAddressPatch] { + return pulumix.Output[EndpointAddressPatch]{ + OutputState: i.ToEndpointAddressPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointAddressPatchArrayInput is an input type that accepts EndpointAddressPatchArray and EndpointAddressPatchArrayOutput values. // You can construct a concrete instance of `EndpointAddressPatchArrayInput` via: // @@ -13709,6 +15540,12 @@ func (i EndpointAddressPatchArray) ToEndpointAddressPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(EndpointAddressPatchArrayOutput) } +func (i EndpointAddressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointAddressPatch] { + return pulumix.Output[[]EndpointAddressPatch]{ + OutputState: i.ToEndpointAddressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointAddress is a tuple that describes single IP address. type EndpointAddressPatchOutput struct{ *pulumi.OutputState } @@ -13724,6 +15561,12 @@ func (o EndpointAddressPatchOutput) ToEndpointAddressPatchOutputWithContext(ctx return o } +func (o EndpointAddressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointAddressPatch] { + return pulumix.Output[EndpointAddressPatch]{ + OutputState: o.OutputState, + } +} + // The Hostname of this endpoint func (o EndpointAddressPatchOutput) Hostname() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointAddressPatch) *string { return v.Hostname }).(pulumi.StringPtrOutput) @@ -13758,6 +15601,12 @@ func (o EndpointAddressPatchArrayOutput) ToEndpointAddressPatchArrayOutputWithCo return o } +func (o EndpointAddressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointAddressPatch] { + return pulumix.Output[[]EndpointAddressPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointAddressPatchArrayOutput) Index(i pulumi.IntInput) EndpointAddressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointAddressPatch { return vs[0].([]EndpointAddressPatch)[vs[1].(int)] @@ -13829,6 +15678,12 @@ func (i EndpointPortArgs) ToEndpointPortOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EndpointPortOutput) } +func (i EndpointPortArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPort] { + return pulumix.Output[EndpointPort]{ + OutputState: i.ToEndpointPortOutputWithContext(ctx).OutputState, + } +} + // EndpointPortArrayInput is an input type that accepts EndpointPortArray and EndpointPortArrayOutput values. // You can construct a concrete instance of `EndpointPortArrayInput` via: // @@ -13854,6 +15709,12 @@ func (i EndpointPortArray) ToEndpointPortArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(EndpointPortArrayOutput) } +func (i EndpointPortArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPort] { + return pulumix.Output[[]EndpointPort]{ + OutputState: i.ToEndpointPortArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointPort is a tuple that describes a single port. type EndpointPortOutput struct{ *pulumi.OutputState } @@ -13869,6 +15730,12 @@ func (o EndpointPortOutput) ToEndpointPortOutputWithContext(ctx context.Context) return o } +func (o EndpointPortOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPort] { + return pulumix.Output[EndpointPort]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either: // // * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). @@ -13912,6 +15779,12 @@ func (o EndpointPortArrayOutput) ToEndpointPortArrayOutputWithContext(ctx contex return o } +func (o EndpointPortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPort] { + return pulumix.Output[[]EndpointPort]{ + OutputState: o.OutputState, + } +} + func (o EndpointPortArrayOutput) Index(i pulumi.IntInput) EndpointPortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPort { return vs[0].([]EndpointPort)[vs[1].(int)] @@ -13983,6 +15856,12 @@ func (i EndpointPortPatchArgs) ToEndpointPortPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointPortPatchOutput) } +func (i EndpointPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPortPatch] { + return pulumix.Output[EndpointPortPatch]{ + OutputState: i.ToEndpointPortPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointPortPatchArrayInput is an input type that accepts EndpointPortPatchArray and EndpointPortPatchArrayOutput values. // You can construct a concrete instance of `EndpointPortPatchArrayInput` via: // @@ -14008,6 +15887,12 @@ func (i EndpointPortPatchArray) ToEndpointPortPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointPortPatchArrayOutput) } +func (i EndpointPortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPortPatch] { + return pulumix.Output[[]EndpointPortPatch]{ + OutputState: i.ToEndpointPortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointPort is a tuple that describes a single port. type EndpointPortPatchOutput struct{ *pulumi.OutputState } @@ -14023,6 +15908,12 @@ func (o EndpointPortPatchOutput) ToEndpointPortPatchOutputWithContext(ctx contex return o } +func (o EndpointPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPortPatch] { + return pulumix.Output[EndpointPortPatch]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either: // // * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). @@ -14066,6 +15957,12 @@ func (o EndpointPortPatchArrayOutput) ToEndpointPortPatchArrayOutputWithContext( return o } +func (o EndpointPortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPortPatch] { + return pulumix.Output[[]EndpointPortPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointPortPatchArrayOutput) Index(i pulumi.IntInput) EndpointPortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPortPatch { return vs[0].([]EndpointPortPatch)[vs[1].(int)] @@ -14135,6 +16032,12 @@ func (i EndpointSubsetArgs) ToEndpointSubsetOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EndpointSubsetOutput) } +func (i EndpointSubsetArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSubset] { + return pulumix.Output[EndpointSubset]{ + OutputState: i.ToEndpointSubsetOutputWithContext(ctx).OutputState, + } +} + // EndpointSubsetArrayInput is an input type that accepts EndpointSubsetArray and EndpointSubsetArrayOutput values. // You can construct a concrete instance of `EndpointSubsetArrayInput` via: // @@ -14160,6 +16063,12 @@ func (i EndpointSubsetArray) ToEndpointSubsetArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointSubsetArrayOutput) } +func (i EndpointSubsetArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSubset] { + return pulumix.Output[[]EndpointSubset]{ + OutputState: i.ToEndpointSubsetArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given: // // { @@ -14185,6 +16094,12 @@ func (o EndpointSubsetOutput) ToEndpointSubsetOutputWithContext(ctx context.Cont return o } +func (o EndpointSubsetOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSubset] { + return pulumix.Output[EndpointSubset]{ + OutputState: o.OutputState, + } +} + // IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize. func (o EndpointSubsetOutput) Addresses() EndpointAddressArrayOutput { return o.ApplyT(func(v EndpointSubset) []EndpointAddress { return v.Addresses }).(EndpointAddressArrayOutput) @@ -14214,6 +16129,12 @@ func (o EndpointSubsetArrayOutput) ToEndpointSubsetArrayOutputWithContext(ctx co return o } +func (o EndpointSubsetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSubset] { + return pulumix.Output[[]EndpointSubset]{ + OutputState: o.OutputState, + } +} + func (o EndpointSubsetArrayOutput) Index(i pulumi.IntInput) EndpointSubsetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointSubset { return vs[0].([]EndpointSubset)[vs[1].(int)] @@ -14283,6 +16204,12 @@ func (i EndpointSubsetPatchArgs) ToEndpointSubsetPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(EndpointSubsetPatchOutput) } +func (i EndpointSubsetPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSubsetPatch] { + return pulumix.Output[EndpointSubsetPatch]{ + OutputState: i.ToEndpointSubsetPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointSubsetPatchArrayInput is an input type that accepts EndpointSubsetPatchArray and EndpointSubsetPatchArrayOutput values. // You can construct a concrete instance of `EndpointSubsetPatchArrayInput` via: // @@ -14308,6 +16235,12 @@ func (i EndpointSubsetPatchArray) ToEndpointSubsetPatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(EndpointSubsetPatchArrayOutput) } +func (i EndpointSubsetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSubsetPatch] { + return pulumix.Output[[]EndpointSubsetPatch]{ + OutputState: i.ToEndpointSubsetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given: // // { @@ -14333,6 +16266,12 @@ func (o EndpointSubsetPatchOutput) ToEndpointSubsetPatchOutputWithContext(ctx co return o } +func (o EndpointSubsetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSubsetPatch] { + return pulumix.Output[EndpointSubsetPatch]{ + OutputState: o.OutputState, + } +} + // IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize. func (o EndpointSubsetPatchOutput) Addresses() EndpointAddressPatchArrayOutput { return o.ApplyT(func(v EndpointSubsetPatch) []EndpointAddressPatch { return v.Addresses }).(EndpointAddressPatchArrayOutput) @@ -14362,6 +16301,12 @@ func (o EndpointSubsetPatchArrayOutput) ToEndpointSubsetPatchArrayOutputWithCont return o } +func (o EndpointSubsetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSubsetPatch] { + return pulumix.Output[[]EndpointSubsetPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointSubsetPatchArrayOutput) Index(i pulumi.IntInput) EndpointSubsetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointSubsetPatch { return vs[0].([]EndpointSubsetPatch)[vs[1].(int)] @@ -14439,6 +16384,12 @@ func (i EndpointsTypeArgs) ToEndpointsTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EndpointsTypeOutput) } +func (i EndpointsTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointsType] { + return pulumix.Output[EndpointsType]{ + OutputState: i.ToEndpointsTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointsTypeArrayInput is an input type that accepts EndpointsTypeArray and EndpointsTypeArrayOutput values. // You can construct a concrete instance of `EndpointsTypeArrayInput` via: // @@ -14464,6 +16415,12 @@ func (i EndpointsTypeArray) ToEndpointsTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EndpointsTypeArrayOutput) } +func (i EndpointsTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointsType] { + return pulumix.Output[[]EndpointsType]{ + OutputState: i.ToEndpointsTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Endpoints is a collection of endpoints that implement the actual service. Example: // // Name: "mysvc", @@ -14491,6 +16448,12 @@ func (o EndpointsTypeOutput) ToEndpointsTypeOutputWithContext(ctx context.Contex return o } +func (o EndpointsTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointsType] { + return pulumix.Output[EndpointsType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointsTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointsType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -14525,6 +16488,12 @@ func (o EndpointsTypeArrayOutput) ToEndpointsTypeArrayOutputWithContext(ctx cont return o } +func (o EndpointsTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointsType] { + return pulumix.Output[[]EndpointsType]{ + OutputState: o.OutputState, + } +} + func (o EndpointsTypeArrayOutput) Index(i pulumi.IntInput) EndpointsTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointsType { return vs[0].([]EndpointsType)[vs[1].(int)] @@ -14578,6 +16547,12 @@ func (i EndpointsListTypeArgs) ToEndpointsListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointsListTypeOutput) } +func (i EndpointsListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointsListType] { + return pulumix.Output[EndpointsListType]{ + OutputState: i.ToEndpointsListTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointsList is a list of endpoints. type EndpointsListTypeOutput struct{ *pulumi.OutputState } @@ -14593,6 +16568,12 @@ func (o EndpointsListTypeOutput) ToEndpointsListTypeOutputWithContext(ctx contex return o } +func (o EndpointsListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointsListType] { + return pulumix.Output[EndpointsListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointsListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointsListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -14684,6 +16665,12 @@ func (i EndpointsPatchTypeArgs) ToEndpointsPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointsPatchTypeOutput) } +func (i EndpointsPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointsPatchType] { + return pulumix.Output[EndpointsPatchType]{ + OutputState: i.ToEndpointsPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Endpoints is a collection of endpoints that implement the actual service. Example: // // Name: "mysvc", @@ -14711,6 +16698,12 @@ func (o EndpointsPatchTypeOutput) ToEndpointsPatchTypeOutputWithContext(ctx cont return o } +func (o EndpointsPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointsPatchType] { + return pulumix.Output[EndpointsPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointsPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointsPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -14774,6 +16767,12 @@ func (i EnvFromSourceArgs) ToEnvFromSourceOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EnvFromSourceOutput) } +func (i EnvFromSourceArgs) ToOutput(ctx context.Context) pulumix.Output[EnvFromSource] { + return pulumix.Output[EnvFromSource]{ + OutputState: i.ToEnvFromSourceOutputWithContext(ctx).OutputState, + } +} + // EnvFromSourceArrayInput is an input type that accepts EnvFromSourceArray and EnvFromSourceArrayOutput values. // You can construct a concrete instance of `EnvFromSourceArrayInput` via: // @@ -14799,6 +16798,12 @@ func (i EnvFromSourceArray) ToEnvFromSourceArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EnvFromSourceArrayOutput) } +func (i EnvFromSourceArray) ToOutput(ctx context.Context) pulumix.Output[[]EnvFromSource] { + return pulumix.Output[[]EnvFromSource]{ + OutputState: i.ToEnvFromSourceArrayOutputWithContext(ctx).OutputState, + } +} + // EnvFromSource represents the source of a set of ConfigMaps type EnvFromSourceOutput struct{ *pulumi.OutputState } @@ -14814,6 +16819,12 @@ func (o EnvFromSourceOutput) ToEnvFromSourceOutputWithContext(ctx context.Contex return o } +func (o EnvFromSourceOutput) ToOutput(ctx context.Context) pulumix.Output[EnvFromSource] { + return pulumix.Output[EnvFromSource]{ + OutputState: o.OutputState, + } +} + // The ConfigMap to select from func (o EnvFromSourceOutput) ConfigMapRef() ConfigMapEnvSourcePtrOutput { return o.ApplyT(func(v EnvFromSource) *ConfigMapEnvSource { return v.ConfigMapRef }).(ConfigMapEnvSourcePtrOutput) @@ -14843,6 +16854,12 @@ func (o EnvFromSourceArrayOutput) ToEnvFromSourceArrayOutputWithContext(ctx cont return o } +func (o EnvFromSourceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EnvFromSource] { + return pulumix.Output[[]EnvFromSource]{ + OutputState: o.OutputState, + } +} + func (o EnvFromSourceArrayOutput) Index(i pulumi.IntInput) EnvFromSourceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EnvFromSource { return vs[0].([]EnvFromSource)[vs[1].(int)] @@ -14892,6 +16909,12 @@ func (i EnvFromSourcePatchArgs) ToEnvFromSourcePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EnvFromSourcePatchOutput) } +func (i EnvFromSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[EnvFromSourcePatch] { + return pulumix.Output[EnvFromSourcePatch]{ + OutputState: i.ToEnvFromSourcePatchOutputWithContext(ctx).OutputState, + } +} + // EnvFromSourcePatchArrayInput is an input type that accepts EnvFromSourcePatchArray and EnvFromSourcePatchArrayOutput values. // You can construct a concrete instance of `EnvFromSourcePatchArrayInput` via: // @@ -14917,6 +16940,12 @@ func (i EnvFromSourcePatchArray) ToEnvFromSourcePatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EnvFromSourcePatchArrayOutput) } +func (i EnvFromSourcePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EnvFromSourcePatch] { + return pulumix.Output[[]EnvFromSourcePatch]{ + OutputState: i.ToEnvFromSourcePatchArrayOutputWithContext(ctx).OutputState, + } +} + // EnvFromSource represents the source of a set of ConfigMaps type EnvFromSourcePatchOutput struct{ *pulumi.OutputState } @@ -14932,6 +16961,12 @@ func (o EnvFromSourcePatchOutput) ToEnvFromSourcePatchOutputWithContext(ctx cont return o } +func (o EnvFromSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[EnvFromSourcePatch] { + return pulumix.Output[EnvFromSourcePatch]{ + OutputState: o.OutputState, + } +} + // The ConfigMap to select from func (o EnvFromSourcePatchOutput) ConfigMapRef() ConfigMapEnvSourcePatchPtrOutput { return o.ApplyT(func(v EnvFromSourcePatch) *ConfigMapEnvSourcePatch { return v.ConfigMapRef }).(ConfigMapEnvSourcePatchPtrOutput) @@ -14961,6 +16996,12 @@ func (o EnvFromSourcePatchArrayOutput) ToEnvFromSourcePatchArrayOutputWithContex return o } +func (o EnvFromSourcePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EnvFromSourcePatch] { + return pulumix.Output[[]EnvFromSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o EnvFromSourcePatchArrayOutput) Index(i pulumi.IntInput) EnvFromSourcePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EnvFromSourcePatch { return vs[0].([]EnvFromSourcePatch)[vs[1].(int)] @@ -15010,6 +17051,12 @@ func (i EnvVarArgs) ToEnvVarOutputWithContext(ctx context.Context) EnvVarOutput return pulumi.ToOutputWithContext(ctx, i).(EnvVarOutput) } +func (i EnvVarArgs) ToOutput(ctx context.Context) pulumix.Output[EnvVar] { + return pulumix.Output[EnvVar]{ + OutputState: i.ToEnvVarOutputWithContext(ctx).OutputState, + } +} + // EnvVarArrayInput is an input type that accepts EnvVarArray and EnvVarArrayOutput values. // You can construct a concrete instance of `EnvVarArrayInput` via: // @@ -15035,6 +17082,12 @@ func (i EnvVarArray) ToEnvVarArrayOutputWithContext(ctx context.Context) EnvVarA return pulumi.ToOutputWithContext(ctx, i).(EnvVarArrayOutput) } +func (i EnvVarArray) ToOutput(ctx context.Context) pulumix.Output[[]EnvVar] { + return pulumix.Output[[]EnvVar]{ + OutputState: i.ToEnvVarArrayOutputWithContext(ctx).OutputState, + } +} + // EnvVar represents an environment variable present in a Container. type EnvVarOutput struct{ *pulumi.OutputState } @@ -15050,6 +17103,12 @@ func (o EnvVarOutput) ToEnvVarOutputWithContext(ctx context.Context) EnvVarOutpu return o } +func (o EnvVarOutput) ToOutput(ctx context.Context) pulumix.Output[EnvVar] { + return pulumix.Output[EnvVar]{ + OutputState: o.OutputState, + } +} + // Name of the environment variable. Must be a C_IDENTIFIER. func (o EnvVarOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v EnvVar) string { return v.Name }).(pulumi.StringOutput) @@ -15079,6 +17138,12 @@ func (o EnvVarArrayOutput) ToEnvVarArrayOutputWithContext(ctx context.Context) E return o } +func (o EnvVarArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EnvVar] { + return pulumix.Output[[]EnvVar]{ + OutputState: o.OutputState, + } +} + func (o EnvVarArrayOutput) Index(i pulumi.IntInput) EnvVarOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EnvVar { return vs[0].([]EnvVar)[vs[1].(int)] @@ -15128,6 +17193,12 @@ func (i EnvVarPatchArgs) ToEnvVarPatchOutputWithContext(ctx context.Context) Env return pulumi.ToOutputWithContext(ctx, i).(EnvVarPatchOutput) } +func (i EnvVarPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EnvVarPatch] { + return pulumix.Output[EnvVarPatch]{ + OutputState: i.ToEnvVarPatchOutputWithContext(ctx).OutputState, + } +} + // EnvVarPatchArrayInput is an input type that accepts EnvVarPatchArray and EnvVarPatchArrayOutput values. // You can construct a concrete instance of `EnvVarPatchArrayInput` via: // @@ -15153,6 +17224,12 @@ func (i EnvVarPatchArray) ToEnvVarPatchArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EnvVarPatchArrayOutput) } +func (i EnvVarPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EnvVarPatch] { + return pulumix.Output[[]EnvVarPatch]{ + OutputState: i.ToEnvVarPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EnvVar represents an environment variable present in a Container. type EnvVarPatchOutput struct{ *pulumi.OutputState } @@ -15168,6 +17245,12 @@ func (o EnvVarPatchOutput) ToEnvVarPatchOutputWithContext(ctx context.Context) E return o } +func (o EnvVarPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EnvVarPatch] { + return pulumix.Output[EnvVarPatch]{ + OutputState: o.OutputState, + } +} + // Name of the environment variable. Must be a C_IDENTIFIER. func (o EnvVarPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v EnvVarPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -15197,6 +17280,12 @@ func (o EnvVarPatchArrayOutput) ToEnvVarPatchArrayOutputWithContext(ctx context. return o } +func (o EnvVarPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EnvVarPatch] { + return pulumix.Output[[]EnvVarPatch]{ + OutputState: o.OutputState, + } +} + func (o EnvVarPatchArrayOutput) Index(i pulumi.IntInput) EnvVarPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EnvVarPatch { return vs[0].([]EnvVarPatch)[vs[1].(int)] @@ -15250,6 +17339,12 @@ func (i EnvVarSourceArgs) ToEnvVarSourceOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EnvVarSourceOutput) } +func (i EnvVarSourceArgs) ToOutput(ctx context.Context) pulumix.Output[EnvVarSource] { + return pulumix.Output[EnvVarSource]{ + OutputState: i.ToEnvVarSourceOutputWithContext(ctx).OutputState, + } +} + func (i EnvVarSourceArgs) ToEnvVarSourcePtrOutput() EnvVarSourcePtrOutput { return i.ToEnvVarSourcePtrOutputWithContext(context.Background()) } @@ -15291,6 +17386,12 @@ func (i *envVarSourcePtrType) ToEnvVarSourcePtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(EnvVarSourcePtrOutput) } +func (i *envVarSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*EnvVarSource] { + return pulumix.Output[*EnvVarSource]{ + OutputState: i.ToEnvVarSourcePtrOutputWithContext(ctx).OutputState, + } +} + // EnvVarSource represents a source for the value of an EnvVar. type EnvVarSourceOutput struct{ *pulumi.OutputState } @@ -15316,6 +17417,12 @@ func (o EnvVarSourceOutput) ToEnvVarSourcePtrOutputWithContext(ctx context.Conte }).(EnvVarSourcePtrOutput) } +func (o EnvVarSourceOutput) ToOutput(ctx context.Context) pulumix.Output[EnvVarSource] { + return pulumix.Output[EnvVarSource]{ + OutputState: o.OutputState, + } +} + // Selects a key of a ConfigMap. func (o EnvVarSourceOutput) ConfigMapKeyRef() ConfigMapKeySelectorPtrOutput { return o.ApplyT(func(v EnvVarSource) *ConfigMapKeySelector { return v.ConfigMapKeyRef }).(ConfigMapKeySelectorPtrOutput) @@ -15350,6 +17457,12 @@ func (o EnvVarSourcePtrOutput) ToEnvVarSourcePtrOutputWithContext(ctx context.Co return o } +func (o EnvVarSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EnvVarSource] { + return pulumix.Output[*EnvVarSource]{ + OutputState: o.OutputState, + } +} + func (o EnvVarSourcePtrOutput) Elem() EnvVarSourceOutput { return o.ApplyT(func(v *EnvVarSource) EnvVarSource { if v != nil { @@ -15447,6 +17560,12 @@ func (i EnvVarSourcePatchArgs) ToEnvVarSourcePatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EnvVarSourcePatchOutput) } +func (i EnvVarSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[EnvVarSourcePatch] { + return pulumix.Output[EnvVarSourcePatch]{ + OutputState: i.ToEnvVarSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i EnvVarSourcePatchArgs) ToEnvVarSourcePatchPtrOutput() EnvVarSourcePatchPtrOutput { return i.ToEnvVarSourcePatchPtrOutputWithContext(context.Background()) } @@ -15488,6 +17607,12 @@ func (i *envVarSourcePatchPtrType) ToEnvVarSourcePatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(EnvVarSourcePatchPtrOutput) } +func (i *envVarSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EnvVarSourcePatch] { + return pulumix.Output[*EnvVarSourcePatch]{ + OutputState: i.ToEnvVarSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // EnvVarSource represents a source for the value of an EnvVar. type EnvVarSourcePatchOutput struct{ *pulumi.OutputState } @@ -15513,6 +17638,12 @@ func (o EnvVarSourcePatchOutput) ToEnvVarSourcePatchPtrOutputWithContext(ctx con }).(EnvVarSourcePatchPtrOutput) } +func (o EnvVarSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[EnvVarSourcePatch] { + return pulumix.Output[EnvVarSourcePatch]{ + OutputState: o.OutputState, + } +} + // Selects a key of a ConfigMap. func (o EnvVarSourcePatchOutput) ConfigMapKeyRef() ConfigMapKeySelectorPatchPtrOutput { return o.ApplyT(func(v EnvVarSourcePatch) *ConfigMapKeySelectorPatch { return v.ConfigMapKeyRef }).(ConfigMapKeySelectorPatchPtrOutput) @@ -15547,6 +17678,12 @@ func (o EnvVarSourcePatchPtrOutput) ToEnvVarSourcePatchPtrOutputWithContext(ctx return o } +func (o EnvVarSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EnvVarSourcePatch] { + return pulumix.Output[*EnvVarSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o EnvVarSourcePatchPtrOutput) Elem() EnvVarSourcePatchOutput { return o.ApplyT(func(v *EnvVarSourcePatch) EnvVarSourcePatch { if v != nil { @@ -15736,6 +17873,12 @@ func (i EphemeralContainerArgs) ToEphemeralContainerOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EphemeralContainerOutput) } +func (i EphemeralContainerArgs) ToOutput(ctx context.Context) pulumix.Output[EphemeralContainer] { + return pulumix.Output[EphemeralContainer]{ + OutputState: i.ToEphemeralContainerOutputWithContext(ctx).OutputState, + } +} + // EphemeralContainerArrayInput is an input type that accepts EphemeralContainerArray and EphemeralContainerArrayOutput values. // You can construct a concrete instance of `EphemeralContainerArrayInput` via: // @@ -15761,6 +17904,12 @@ func (i EphemeralContainerArray) ToEphemeralContainerArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EphemeralContainerArrayOutput) } +func (i EphemeralContainerArray) ToOutput(ctx context.Context) pulumix.Output[[]EphemeralContainer] { + return pulumix.Output[[]EphemeralContainer]{ + OutputState: i.ToEphemeralContainerArrayOutputWithContext(ctx).OutputState, + } +} + // An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. // // To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. @@ -15778,6 +17927,12 @@ func (o EphemeralContainerOutput) ToEphemeralContainerOutputWithContext(ctx cont return o } +func (o EphemeralContainerOutput) ToOutput(ctx context.Context) pulumix.Output[EphemeralContainer] { + return pulumix.Output[EphemeralContainer]{ + OutputState: o.OutputState, + } +} + // Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell func (o EphemeralContainerOutput) Args() pulumi.StringArrayOutput { return o.ApplyT(func(v EphemeralContainer) []string { return v.Args }).(pulumi.StringArrayOutput) @@ -15919,6 +18074,12 @@ func (o EphemeralContainerArrayOutput) ToEphemeralContainerArrayOutputWithContex return o } +func (o EphemeralContainerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EphemeralContainer] { + return pulumix.Output[[]EphemeralContainer]{ + OutputState: o.OutputState, + } +} + func (o EphemeralContainerArrayOutput) Index(i pulumi.IntInput) EphemeralContainerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EphemeralContainer { return vs[0].([]EphemeralContainer)[vs[1].(int)] @@ -16064,6 +18225,12 @@ func (i EphemeralContainerPatchArgs) ToEphemeralContainerPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(EphemeralContainerPatchOutput) } +func (i EphemeralContainerPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EphemeralContainerPatch] { + return pulumix.Output[EphemeralContainerPatch]{ + OutputState: i.ToEphemeralContainerPatchOutputWithContext(ctx).OutputState, + } +} + // EphemeralContainerPatchArrayInput is an input type that accepts EphemeralContainerPatchArray and EphemeralContainerPatchArrayOutput values. // You can construct a concrete instance of `EphemeralContainerPatchArrayInput` via: // @@ -16089,6 +18256,12 @@ func (i EphemeralContainerPatchArray) ToEphemeralContainerPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(EphemeralContainerPatchArrayOutput) } +func (i EphemeralContainerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EphemeralContainerPatch] { + return pulumix.Output[[]EphemeralContainerPatch]{ + OutputState: i.ToEphemeralContainerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. // // To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. @@ -16106,6 +18279,12 @@ func (o EphemeralContainerPatchOutput) ToEphemeralContainerPatchOutputWithContex return o } +func (o EphemeralContainerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EphemeralContainerPatch] { + return pulumix.Output[EphemeralContainerPatch]{ + OutputState: o.OutputState, + } +} + // Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell func (o EphemeralContainerPatchOutput) Args() pulumi.StringArrayOutput { return o.ApplyT(func(v EphemeralContainerPatch) []string { return v.Args }).(pulumi.StringArrayOutput) @@ -16247,6 +18426,12 @@ func (o EphemeralContainerPatchArrayOutput) ToEphemeralContainerPatchArrayOutput return o } +func (o EphemeralContainerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EphemeralContainerPatch] { + return pulumix.Output[[]EphemeralContainerPatch]{ + OutputState: o.OutputState, + } +} + func (o EphemeralContainerPatchArrayOutput) Index(i pulumi.IntInput) EphemeralContainerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EphemeralContainerPatch { return vs[0].([]EphemeralContainerPatch)[vs[1].(int)] @@ -16304,6 +18489,12 @@ func (i EphemeralVolumeSourceArgs) ToEphemeralVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EphemeralVolumeSourceOutput) } +func (i EphemeralVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[EphemeralVolumeSource] { + return pulumix.Output[EphemeralVolumeSource]{ + OutputState: i.ToEphemeralVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i EphemeralVolumeSourceArgs) ToEphemeralVolumeSourcePtrOutput() EphemeralVolumeSourcePtrOutput { return i.ToEphemeralVolumeSourcePtrOutputWithContext(context.Background()) } @@ -16345,6 +18536,12 @@ func (i *ephemeralVolumeSourcePtrType) ToEphemeralVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(EphemeralVolumeSourcePtrOutput) } +func (i *ephemeralVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*EphemeralVolumeSource] { + return pulumix.Output[*EphemeralVolumeSource]{ + OutputState: i.ToEphemeralVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents an ephemeral volume that is handled by a normal storage driver. type EphemeralVolumeSourceOutput struct{ *pulumi.OutputState } @@ -16370,6 +18567,12 @@ func (o EphemeralVolumeSourceOutput) ToEphemeralVolumeSourcePtrOutputWithContext }).(EphemeralVolumeSourcePtrOutput) } +func (o EphemeralVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[EphemeralVolumeSource] { + return pulumix.Output[EphemeralVolumeSource]{ + OutputState: o.OutputState, + } +} + // Specifies a read-only configuration for the volume. Defaults to false (read/write). func (o EphemeralVolumeSourceOutput) ReadOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v EphemeralVolumeSource) *bool { return v.ReadOnly }).(pulumi.BoolPtrOutput) @@ -16400,6 +18603,12 @@ func (o EphemeralVolumeSourcePtrOutput) ToEphemeralVolumeSourcePtrOutputWithCont return o } +func (o EphemeralVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EphemeralVolumeSource] { + return pulumix.Output[*EphemeralVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o EphemeralVolumeSourcePtrOutput) Elem() EphemeralVolumeSourceOutput { return o.ApplyT(func(v *EphemeralVolumeSource) EphemeralVolumeSource { if v != nil { @@ -16487,6 +18696,12 @@ func (i EphemeralVolumeSourcePatchArgs) ToEphemeralVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(EphemeralVolumeSourcePatchOutput) } +func (i EphemeralVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[EphemeralVolumeSourcePatch] { + return pulumix.Output[EphemeralVolumeSourcePatch]{ + OutputState: i.ToEphemeralVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i EphemeralVolumeSourcePatchArgs) ToEphemeralVolumeSourcePatchPtrOutput() EphemeralVolumeSourcePatchPtrOutput { return i.ToEphemeralVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -16528,6 +18743,12 @@ func (i *ephemeralVolumeSourcePatchPtrType) ToEphemeralVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(EphemeralVolumeSourcePatchPtrOutput) } +func (i *ephemeralVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EphemeralVolumeSourcePatch] { + return pulumix.Output[*EphemeralVolumeSourcePatch]{ + OutputState: i.ToEphemeralVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents an ephemeral volume that is handled by a normal storage driver. type EphemeralVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -16553,6 +18774,12 @@ func (o EphemeralVolumeSourcePatchOutput) ToEphemeralVolumeSourcePatchPtrOutputW }).(EphemeralVolumeSourcePatchPtrOutput) } +func (o EphemeralVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[EphemeralVolumeSourcePatch] { + return pulumix.Output[EphemeralVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // Specifies a read-only configuration for the volume. Defaults to false (read/write). func (o EphemeralVolumeSourcePatchOutput) ReadOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v EphemeralVolumeSourcePatch) *bool { return v.ReadOnly }).(pulumi.BoolPtrOutput) @@ -16583,6 +18810,12 @@ func (o EphemeralVolumeSourcePatchPtrOutput) ToEphemeralVolumeSourcePatchPtrOutp return o } +func (o EphemeralVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EphemeralVolumeSourcePatch] { + return pulumix.Output[*EphemeralVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o EphemeralVolumeSourcePatchPtrOutput) Elem() EphemeralVolumeSourcePatchOutput { return o.ApplyT(func(v *EphemeralVolumeSourcePatch) EphemeralVolumeSourcePatch { if v != nil { @@ -16718,6 +18951,12 @@ func (i EventTypeArgs) ToEventTypeOutputWithContext(ctx context.Context) EventTy return pulumi.ToOutputWithContext(ctx, i).(EventTypeOutput) } +func (i EventTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventType] { + return pulumix.Output[EventType]{ + OutputState: i.ToEventTypeOutputWithContext(ctx).OutputState, + } +} + // EventTypeArrayInput is an input type that accepts EventTypeArray and EventTypeArrayOutput values. // You can construct a concrete instance of `EventTypeArrayInput` via: // @@ -16743,6 +18982,12 @@ func (i EventTypeArray) ToEventTypeArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EventTypeArrayOutput) } +func (i EventTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]EventType] { + return pulumix.Output[[]EventType]{ + OutputState: i.ToEventTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. type EventTypeOutput struct{ *pulumi.OutputState } @@ -16758,6 +19003,12 @@ func (o EventTypeOutput) ToEventTypeOutputWithContext(ctx context.Context) Event return o } +func (o EventTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventType] { + return pulumix.Output[EventType]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the Regarding object. func (o EventTypeOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v EventType) *string { return v.Action }).(pulumi.StringPtrOutput) @@ -16857,6 +19108,12 @@ func (o EventTypeArrayOutput) ToEventTypeArrayOutputWithContext(ctx context.Cont return o } +func (o EventTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EventType] { + return pulumix.Output[[]EventType]{ + OutputState: o.OutputState, + } +} + func (o EventTypeArrayOutput) Index(i pulumi.IntInput) EventTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EventType { return vs[0].([]EventType)[vs[1].(int)] @@ -16910,6 +19167,12 @@ func (i EventListTypeArgs) ToEventListTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EventListTypeOutput) } +func (i EventListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventListType] { + return pulumix.Output[EventListType]{ + OutputState: i.ToEventListTypeOutputWithContext(ctx).OutputState, + } +} + // EventList is a list of events. type EventListTypeOutput struct{ *pulumi.OutputState } @@ -16925,6 +19188,12 @@ func (o EventListTypeOutput) ToEventListTypeOutputWithContext(ctx context.Contex return o } +func (o EventListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventListType] { + return pulumix.Output[EventListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EventListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EventListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -17044,6 +19313,12 @@ func (i EventPatchTypeArgs) ToEventPatchTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EventPatchTypeOutput) } +func (i EventPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventPatchType] { + return pulumix.Output[EventPatchType]{ + OutputState: i.ToEventPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. type EventPatchTypeOutput struct{ *pulumi.OutputState } @@ -17059,6 +19334,12 @@ func (o EventPatchTypeOutput) ToEventPatchTypeOutputWithContext(ctx context.Cont return o } +func (o EventPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventPatchType] { + return pulumix.Output[EventPatchType]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the Regarding object. func (o EventPatchTypeOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v EventPatchType) *string { return v.Action }).(pulumi.StringPtrOutput) @@ -17187,6 +19468,12 @@ func (i EventSeriesArgs) ToEventSeriesOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventSeriesOutput) } +func (i EventSeriesArgs) ToOutput(ctx context.Context) pulumix.Output[EventSeries] { + return pulumix.Output[EventSeries]{ + OutputState: i.ToEventSeriesOutputWithContext(ctx).OutputState, + } +} + func (i EventSeriesArgs) ToEventSeriesPtrOutput() EventSeriesPtrOutput { return i.ToEventSeriesPtrOutputWithContext(context.Background()) } @@ -17228,6 +19515,12 @@ func (i *eventSeriesPtrType) ToEventSeriesPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPtrOutput) } +func (i *eventSeriesPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSeries] { + return pulumix.Output[*EventSeries]{ + OutputState: i.ToEventSeriesPtrOutputWithContext(ctx).OutputState, + } +} + // EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. type EventSeriesOutput struct{ *pulumi.OutputState } @@ -17253,6 +19546,12 @@ func (o EventSeriesOutput) ToEventSeriesPtrOutputWithContext(ctx context.Context }).(EventSeriesPtrOutput) } +func (o EventSeriesOutput) ToOutput(ctx context.Context) pulumix.Output[EventSeries] { + return pulumix.Output[EventSeries]{ + OutputState: o.OutputState, + } +} + // Number of occurrences in this series up to the last heartbeat time func (o EventSeriesOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v EventSeries) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -17282,6 +19581,12 @@ func (o EventSeriesPtrOutput) ToEventSeriesPtrOutputWithContext(ctx context.Cont return o } +func (o EventSeriesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSeries] { + return pulumix.Output[*EventSeries]{ + OutputState: o.OutputState, + } +} + func (o EventSeriesPtrOutput) Elem() EventSeriesOutput { return o.ApplyT(func(v *EventSeries) EventSeries { if v != nil { @@ -17365,6 +19670,12 @@ func (i EventSeriesPatchArgs) ToEventSeriesPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPatchOutput) } +func (i EventSeriesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EventSeriesPatch] { + return pulumix.Output[EventSeriesPatch]{ + OutputState: i.ToEventSeriesPatchOutputWithContext(ctx).OutputState, + } +} + func (i EventSeriesPatchArgs) ToEventSeriesPatchPtrOutput() EventSeriesPatchPtrOutput { return i.ToEventSeriesPatchPtrOutputWithContext(context.Background()) } @@ -17406,6 +19717,12 @@ func (i *eventSeriesPatchPtrType) ToEventSeriesPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPatchPtrOutput) } +func (i *eventSeriesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSeriesPatch] { + return pulumix.Output[*EventSeriesPatch]{ + OutputState: i.ToEventSeriesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. type EventSeriesPatchOutput struct{ *pulumi.OutputState } @@ -17431,6 +19748,12 @@ func (o EventSeriesPatchOutput) ToEventSeriesPatchPtrOutputWithContext(ctx conte }).(EventSeriesPatchPtrOutput) } +func (o EventSeriesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EventSeriesPatch] { + return pulumix.Output[EventSeriesPatch]{ + OutputState: o.OutputState, + } +} + // Number of occurrences in this series up to the last heartbeat time func (o EventSeriesPatchOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v EventSeriesPatch) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -17460,6 +19783,12 @@ func (o EventSeriesPatchPtrOutput) ToEventSeriesPatchPtrOutputWithContext(ctx co return o } +func (o EventSeriesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSeriesPatch] { + return pulumix.Output[*EventSeriesPatch]{ + OutputState: o.OutputState, + } +} + func (o EventSeriesPatchPtrOutput) Elem() EventSeriesPatchOutput { return o.ApplyT(func(v *EventSeriesPatch) EventSeriesPatch { if v != nil { @@ -17539,6 +19868,12 @@ func (i EventSourceArgs) ToEventSourceOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventSourceOutput) } +func (i EventSourceArgs) ToOutput(ctx context.Context) pulumix.Output[EventSource] { + return pulumix.Output[EventSource]{ + OutputState: i.ToEventSourceOutputWithContext(ctx).OutputState, + } +} + func (i EventSourceArgs) ToEventSourcePtrOutput() EventSourcePtrOutput { return i.ToEventSourcePtrOutputWithContext(context.Background()) } @@ -17580,6 +19915,12 @@ func (i *eventSourcePtrType) ToEventSourcePtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(EventSourcePtrOutput) } +func (i *eventSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSource] { + return pulumix.Output[*EventSource]{ + OutputState: i.ToEventSourcePtrOutputWithContext(ctx).OutputState, + } +} + // EventSource contains information for an event. type EventSourceOutput struct{ *pulumi.OutputState } @@ -17605,6 +19946,12 @@ func (o EventSourceOutput) ToEventSourcePtrOutputWithContext(ctx context.Context }).(EventSourcePtrOutput) } +func (o EventSourceOutput) ToOutput(ctx context.Context) pulumix.Output[EventSource] { + return pulumix.Output[EventSource]{ + OutputState: o.OutputState, + } +} + // Component from which the event is generated. func (o EventSourceOutput) Component() pulumi.StringPtrOutput { return o.ApplyT(func(v EventSource) *string { return v.Component }).(pulumi.StringPtrOutput) @@ -17629,6 +19976,12 @@ func (o EventSourcePtrOutput) ToEventSourcePtrOutputWithContext(ctx context.Cont return o } +func (o EventSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSource] { + return pulumix.Output[*EventSource]{ + OutputState: o.OutputState, + } +} + func (o EventSourcePtrOutput) Elem() EventSourceOutput { return o.ApplyT(func(v *EventSource) EventSource { if v != nil { @@ -17698,6 +20051,12 @@ func (i EventSourcePatchArgs) ToEventSourcePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EventSourcePatchOutput) } +func (i EventSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[EventSourcePatch] { + return pulumix.Output[EventSourcePatch]{ + OutputState: i.ToEventSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i EventSourcePatchArgs) ToEventSourcePatchPtrOutput() EventSourcePatchPtrOutput { return i.ToEventSourcePatchPtrOutputWithContext(context.Background()) } @@ -17739,6 +20098,12 @@ func (i *eventSourcePatchPtrType) ToEventSourcePatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(EventSourcePatchPtrOutput) } +func (i *eventSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSourcePatch] { + return pulumix.Output[*EventSourcePatch]{ + OutputState: i.ToEventSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // EventSource contains information for an event. type EventSourcePatchOutput struct{ *pulumi.OutputState } @@ -17764,6 +20129,12 @@ func (o EventSourcePatchOutput) ToEventSourcePatchPtrOutputWithContext(ctx conte }).(EventSourcePatchPtrOutput) } +func (o EventSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[EventSourcePatch] { + return pulumix.Output[EventSourcePatch]{ + OutputState: o.OutputState, + } +} + // Component from which the event is generated. func (o EventSourcePatchOutput) Component() pulumi.StringPtrOutput { return o.ApplyT(func(v EventSourcePatch) *string { return v.Component }).(pulumi.StringPtrOutput) @@ -17788,6 +20159,12 @@ func (o EventSourcePatchPtrOutput) ToEventSourcePatchPtrOutputWithContext(ctx co return o } +func (o EventSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSourcePatch] { + return pulumix.Output[*EventSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o EventSourcePatchPtrOutput) Elem() EventSourcePatchOutput { return o.ApplyT(func(v *EventSourcePatch) EventSourcePatch { if v != nil { @@ -17853,6 +20230,12 @@ func (i ExecActionArgs) ToExecActionOutputWithContext(ctx context.Context) ExecA return pulumi.ToOutputWithContext(ctx, i).(ExecActionOutput) } +func (i ExecActionArgs) ToOutput(ctx context.Context) pulumix.Output[ExecAction] { + return pulumix.Output[ExecAction]{ + OutputState: i.ToExecActionOutputWithContext(ctx).OutputState, + } +} + func (i ExecActionArgs) ToExecActionPtrOutput() ExecActionPtrOutput { return i.ToExecActionPtrOutputWithContext(context.Background()) } @@ -17894,6 +20277,12 @@ func (i *execActionPtrType) ToExecActionPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ExecActionPtrOutput) } +func (i *execActionPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExecAction] { + return pulumix.Output[*ExecAction]{ + OutputState: i.ToExecActionPtrOutputWithContext(ctx).OutputState, + } +} + // ExecAction describes a "run in container" action. type ExecActionOutput struct{ *pulumi.OutputState } @@ -17919,6 +20308,12 @@ func (o ExecActionOutput) ToExecActionPtrOutputWithContext(ctx context.Context) }).(ExecActionPtrOutput) } +func (o ExecActionOutput) ToOutput(ctx context.Context) pulumix.Output[ExecAction] { + return pulumix.Output[ExecAction]{ + OutputState: o.OutputState, + } +} + // Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. func (o ExecActionOutput) Command() pulumi.StringArrayOutput { return o.ApplyT(func(v ExecAction) []string { return v.Command }).(pulumi.StringArrayOutput) @@ -17938,6 +20333,12 @@ func (o ExecActionPtrOutput) ToExecActionPtrOutputWithContext(ctx context.Contex return o } +func (o ExecActionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExecAction] { + return pulumix.Output[*ExecAction]{ + OutputState: o.OutputState, + } +} + func (o ExecActionPtrOutput) Elem() ExecActionOutput { return o.ApplyT(func(v *ExecAction) ExecAction { if v != nil { @@ -17993,6 +20394,12 @@ func (i ExecActionPatchArgs) ToExecActionPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ExecActionPatchOutput) } +func (i ExecActionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExecActionPatch] { + return pulumix.Output[ExecActionPatch]{ + OutputState: i.ToExecActionPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExecActionPatchArgs) ToExecActionPatchPtrOutput() ExecActionPatchPtrOutput { return i.ToExecActionPatchPtrOutputWithContext(context.Background()) } @@ -18034,6 +20441,12 @@ func (i *execActionPatchPtrType) ToExecActionPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(ExecActionPatchPtrOutput) } +func (i *execActionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExecActionPatch] { + return pulumix.Output[*ExecActionPatch]{ + OutputState: i.ToExecActionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExecAction describes a "run in container" action. type ExecActionPatchOutput struct{ *pulumi.OutputState } @@ -18059,6 +20472,12 @@ func (o ExecActionPatchOutput) ToExecActionPatchPtrOutputWithContext(ctx context }).(ExecActionPatchPtrOutput) } +func (o ExecActionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExecActionPatch] { + return pulumix.Output[ExecActionPatch]{ + OutputState: o.OutputState, + } +} + // Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. func (o ExecActionPatchOutput) Command() pulumi.StringArrayOutput { return o.ApplyT(func(v ExecActionPatch) []string { return v.Command }).(pulumi.StringArrayOutput) @@ -18078,6 +20497,12 @@ func (o ExecActionPatchPtrOutput) ToExecActionPatchPtrOutputWithContext(ctx cont return o } +func (o ExecActionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExecActionPatch] { + return pulumix.Output[*ExecActionPatch]{ + OutputState: o.OutputState, + } +} + func (o ExecActionPatchPtrOutput) Elem() ExecActionPatchOutput { return o.ApplyT(func(v *ExecActionPatch) ExecActionPatch { if v != nil { @@ -18149,6 +20574,12 @@ func (i FCVolumeSourceArgs) ToFCVolumeSourceOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FCVolumeSourceOutput) } +func (i FCVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[FCVolumeSource] { + return pulumix.Output[FCVolumeSource]{ + OutputState: i.ToFCVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i FCVolumeSourceArgs) ToFCVolumeSourcePtrOutput() FCVolumeSourcePtrOutput { return i.ToFCVolumeSourcePtrOutputWithContext(context.Background()) } @@ -18190,6 +20621,12 @@ func (i *fcvolumeSourcePtrType) ToFCVolumeSourcePtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(FCVolumeSourcePtrOutput) } +func (i *fcvolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*FCVolumeSource] { + return pulumix.Output[*FCVolumeSource]{ + OutputState: i.ToFCVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling. type FCVolumeSourceOutput struct{ *pulumi.OutputState } @@ -18215,6 +20652,12 @@ func (o FCVolumeSourceOutput) ToFCVolumeSourcePtrOutputWithContext(ctx context.C }).(FCVolumeSourcePtrOutput) } +func (o FCVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[FCVolumeSource] { + return pulumix.Output[FCVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o FCVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v FCVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -18254,6 +20697,12 @@ func (o FCVolumeSourcePtrOutput) ToFCVolumeSourcePtrOutputWithContext(ctx contex return o } +func (o FCVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FCVolumeSource] { + return pulumix.Output[*FCVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o FCVolumeSourcePtrOutput) Elem() FCVolumeSourceOutput { return o.ApplyT(func(v *FCVolumeSource) FCVolumeSource { if v != nil { @@ -18365,6 +20814,12 @@ func (i FCVolumeSourcePatchArgs) ToFCVolumeSourcePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FCVolumeSourcePatchOutput) } +func (i FCVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[FCVolumeSourcePatch] { + return pulumix.Output[FCVolumeSourcePatch]{ + OutputState: i.ToFCVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i FCVolumeSourcePatchArgs) ToFCVolumeSourcePatchPtrOutput() FCVolumeSourcePatchPtrOutput { return i.ToFCVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -18406,6 +20861,12 @@ func (i *fcvolumeSourcePatchPtrType) ToFCVolumeSourcePatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(FCVolumeSourcePatchPtrOutput) } +func (i *fcvolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FCVolumeSourcePatch] { + return pulumix.Output[*FCVolumeSourcePatch]{ + OutputState: i.ToFCVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling. type FCVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -18431,6 +20892,12 @@ func (o FCVolumeSourcePatchOutput) ToFCVolumeSourcePatchPtrOutputWithContext(ctx }).(FCVolumeSourcePatchPtrOutput) } +func (o FCVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[FCVolumeSourcePatch] { + return pulumix.Output[FCVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o FCVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v FCVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -18470,6 +20937,12 @@ func (o FCVolumeSourcePatchPtrOutput) ToFCVolumeSourcePatchPtrOutputWithContext( return o } +func (o FCVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FCVolumeSourcePatch] { + return pulumix.Output[*FCVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o FCVolumeSourcePatchPtrOutput) Elem() FCVolumeSourcePatchOutput { return o.ApplyT(func(v *FCVolumeSourcePatch) FCVolumeSourcePatch { if v != nil { @@ -18581,6 +21054,12 @@ func (i FlexPersistentVolumeSourceArgs) ToFlexPersistentVolumeSourceOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(FlexPersistentVolumeSourceOutput) } +func (i FlexPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[FlexPersistentVolumeSource] { + return pulumix.Output[FlexPersistentVolumeSource]{ + OutputState: i.ToFlexPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i FlexPersistentVolumeSourceArgs) ToFlexPersistentVolumeSourcePtrOutput() FlexPersistentVolumeSourcePtrOutput { return i.ToFlexPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -18622,6 +21101,12 @@ func (i *flexPersistentVolumeSourcePtrType) ToFlexPersistentVolumeSourcePtrOutpu return pulumi.ToOutputWithContext(ctx, i).(FlexPersistentVolumeSourcePtrOutput) } +func (i *flexPersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*FlexPersistentVolumeSource] { + return pulumix.Output[*FlexPersistentVolumeSource]{ + OutputState: i.ToFlexPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin. type FlexPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -18647,6 +21132,12 @@ func (o FlexPersistentVolumeSourceOutput) ToFlexPersistentVolumeSourcePtrOutputW }).(FlexPersistentVolumeSourcePtrOutput) } +func (o FlexPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[FlexPersistentVolumeSource] { + return pulumix.Output[FlexPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // driver is the name of the driver to use for this volume. func (o FlexPersistentVolumeSourceOutput) Driver() pulumi.StringOutput { return o.ApplyT(func(v FlexPersistentVolumeSource) string { return v.Driver }).(pulumi.StringOutput) @@ -18686,6 +21177,12 @@ func (o FlexPersistentVolumeSourcePtrOutput) ToFlexPersistentVolumeSourcePtrOutp return o } +func (o FlexPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlexPersistentVolumeSource] { + return pulumix.Output[*FlexPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o FlexPersistentVolumeSourcePtrOutput) Elem() FlexPersistentVolumeSourceOutput { return o.ApplyT(func(v *FlexPersistentVolumeSource) FlexPersistentVolumeSource { if v != nil { @@ -18797,6 +21294,12 @@ func (i FlexPersistentVolumeSourcePatchArgs) ToFlexPersistentVolumeSourcePatchOu return pulumi.ToOutputWithContext(ctx, i).(FlexPersistentVolumeSourcePatchOutput) } +func (i FlexPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlexPersistentVolumeSourcePatch] { + return pulumix.Output[FlexPersistentVolumeSourcePatch]{ + OutputState: i.ToFlexPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i FlexPersistentVolumeSourcePatchArgs) ToFlexPersistentVolumeSourcePatchPtrOutput() FlexPersistentVolumeSourcePatchPtrOutput { return i.ToFlexPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -18838,6 +21341,12 @@ func (i *flexPersistentVolumeSourcePatchPtrType) ToFlexPersistentVolumeSourcePat return pulumi.ToOutputWithContext(ctx, i).(FlexPersistentVolumeSourcePatchPtrOutput) } +func (i *flexPersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlexPersistentVolumeSourcePatch] { + return pulumix.Output[*FlexPersistentVolumeSourcePatch]{ + OutputState: i.ToFlexPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin. type FlexPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -18863,6 +21372,12 @@ func (o FlexPersistentVolumeSourcePatchOutput) ToFlexPersistentVolumeSourcePatch }).(FlexPersistentVolumeSourcePatchPtrOutput) } +func (o FlexPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlexPersistentVolumeSourcePatch] { + return pulumix.Output[FlexPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // driver is the name of the driver to use for this volume. func (o FlexPersistentVolumeSourcePatchOutput) Driver() pulumi.StringPtrOutput { return o.ApplyT(func(v FlexPersistentVolumeSourcePatch) *string { return v.Driver }).(pulumi.StringPtrOutput) @@ -18902,6 +21417,12 @@ func (o FlexPersistentVolumeSourcePatchPtrOutput) ToFlexPersistentVolumeSourcePa return o } +func (o FlexPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlexPersistentVolumeSourcePatch] { + return pulumix.Output[*FlexPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o FlexPersistentVolumeSourcePatchPtrOutput) Elem() FlexPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *FlexPersistentVolumeSourcePatch) FlexPersistentVolumeSourcePatch { if v != nil { @@ -19013,6 +21534,12 @@ func (i FlexVolumeSourceArgs) ToFlexVolumeSourceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlexVolumeSourceOutput) } +func (i FlexVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[FlexVolumeSource] { + return pulumix.Output[FlexVolumeSource]{ + OutputState: i.ToFlexVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i FlexVolumeSourceArgs) ToFlexVolumeSourcePtrOutput() FlexVolumeSourcePtrOutput { return i.ToFlexVolumeSourcePtrOutputWithContext(context.Background()) } @@ -19054,6 +21581,12 @@ func (i *flexVolumeSourcePtrType) ToFlexVolumeSourcePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(FlexVolumeSourcePtrOutput) } +func (i *flexVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*FlexVolumeSource] { + return pulumix.Output[*FlexVolumeSource]{ + OutputState: i.ToFlexVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. type FlexVolumeSourceOutput struct{ *pulumi.OutputState } @@ -19079,6 +21612,12 @@ func (o FlexVolumeSourceOutput) ToFlexVolumeSourcePtrOutputWithContext(ctx conte }).(FlexVolumeSourcePtrOutput) } +func (o FlexVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[FlexVolumeSource] { + return pulumix.Output[FlexVolumeSource]{ + OutputState: o.OutputState, + } +} + // driver is the name of the driver to use for this volume. func (o FlexVolumeSourceOutput) Driver() pulumi.StringOutput { return o.ApplyT(func(v FlexVolumeSource) string { return v.Driver }).(pulumi.StringOutput) @@ -19118,6 +21657,12 @@ func (o FlexVolumeSourcePtrOutput) ToFlexVolumeSourcePtrOutputWithContext(ctx co return o } +func (o FlexVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlexVolumeSource] { + return pulumix.Output[*FlexVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o FlexVolumeSourcePtrOutput) Elem() FlexVolumeSourceOutput { return o.ApplyT(func(v *FlexVolumeSource) FlexVolumeSource { if v != nil { @@ -19229,6 +21774,12 @@ func (i FlexVolumeSourcePatchArgs) ToFlexVolumeSourcePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(FlexVolumeSourcePatchOutput) } +func (i FlexVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlexVolumeSourcePatch] { + return pulumix.Output[FlexVolumeSourcePatch]{ + OutputState: i.ToFlexVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i FlexVolumeSourcePatchArgs) ToFlexVolumeSourcePatchPtrOutput() FlexVolumeSourcePatchPtrOutput { return i.ToFlexVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -19270,6 +21821,12 @@ func (i *flexVolumeSourcePatchPtrType) ToFlexVolumeSourcePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(FlexVolumeSourcePatchPtrOutput) } +func (i *flexVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlexVolumeSourcePatch] { + return pulumix.Output[*FlexVolumeSourcePatch]{ + OutputState: i.ToFlexVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. type FlexVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -19295,6 +21852,12 @@ func (o FlexVolumeSourcePatchOutput) ToFlexVolumeSourcePatchPtrOutputWithContext }).(FlexVolumeSourcePatchPtrOutput) } +func (o FlexVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlexVolumeSourcePatch] { + return pulumix.Output[FlexVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // driver is the name of the driver to use for this volume. func (o FlexVolumeSourcePatchOutput) Driver() pulumi.StringPtrOutput { return o.ApplyT(func(v FlexVolumeSourcePatch) *string { return v.Driver }).(pulumi.StringPtrOutput) @@ -19334,6 +21897,12 @@ func (o FlexVolumeSourcePatchPtrOutput) ToFlexVolumeSourcePatchPtrOutputWithCont return o } +func (o FlexVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlexVolumeSourcePatch] { + return pulumix.Output[*FlexVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o FlexVolumeSourcePatchPtrOutput) Elem() FlexVolumeSourcePatchOutput { return o.ApplyT(func(v *FlexVolumeSourcePatch) FlexVolumeSourcePatch { if v != nil { @@ -19433,6 +22002,12 @@ func (i FlockerVolumeSourceArgs) ToFlockerVolumeSourceOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlockerVolumeSourceOutput) } +func (i FlockerVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[FlockerVolumeSource] { + return pulumix.Output[FlockerVolumeSource]{ + OutputState: i.ToFlockerVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i FlockerVolumeSourceArgs) ToFlockerVolumeSourcePtrOutput() FlockerVolumeSourcePtrOutput { return i.ToFlockerVolumeSourcePtrOutputWithContext(context.Background()) } @@ -19474,6 +22049,12 @@ func (i *flockerVolumeSourcePtrType) ToFlockerVolumeSourcePtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(FlockerVolumeSourcePtrOutput) } +func (i *flockerVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*FlockerVolumeSource] { + return pulumix.Output[*FlockerVolumeSource]{ + OutputState: i.ToFlockerVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling. type FlockerVolumeSourceOutput struct{ *pulumi.OutputState } @@ -19499,6 +22080,12 @@ func (o FlockerVolumeSourceOutput) ToFlockerVolumeSourcePtrOutputWithContext(ctx }).(FlockerVolumeSourcePtrOutput) } +func (o FlockerVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[FlockerVolumeSource] { + return pulumix.Output[FlockerVolumeSource]{ + OutputState: o.OutputState, + } +} + // datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated func (o FlockerVolumeSourceOutput) DatasetName() pulumi.StringPtrOutput { return o.ApplyT(func(v FlockerVolumeSource) *string { return v.DatasetName }).(pulumi.StringPtrOutput) @@ -19523,6 +22110,12 @@ func (o FlockerVolumeSourcePtrOutput) ToFlockerVolumeSourcePtrOutputWithContext( return o } +func (o FlockerVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlockerVolumeSource] { + return pulumix.Output[*FlockerVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o FlockerVolumeSourcePtrOutput) Elem() FlockerVolumeSourceOutput { return o.ApplyT(func(v *FlockerVolumeSource) FlockerVolumeSource { if v != nil { @@ -19592,6 +22185,12 @@ func (i FlockerVolumeSourcePatchArgs) ToFlockerVolumeSourcePatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(FlockerVolumeSourcePatchOutput) } +func (i FlockerVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlockerVolumeSourcePatch] { + return pulumix.Output[FlockerVolumeSourcePatch]{ + OutputState: i.ToFlockerVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i FlockerVolumeSourcePatchArgs) ToFlockerVolumeSourcePatchPtrOutput() FlockerVolumeSourcePatchPtrOutput { return i.ToFlockerVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -19633,6 +22232,12 @@ func (i *flockerVolumeSourcePatchPtrType) ToFlockerVolumeSourcePatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(FlockerVolumeSourcePatchPtrOutput) } +func (i *flockerVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlockerVolumeSourcePatch] { + return pulumix.Output[*FlockerVolumeSourcePatch]{ + OutputState: i.ToFlockerVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling. type FlockerVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -19658,6 +22263,12 @@ func (o FlockerVolumeSourcePatchOutput) ToFlockerVolumeSourcePatchPtrOutputWithC }).(FlockerVolumeSourcePatchPtrOutput) } +func (o FlockerVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlockerVolumeSourcePatch] { + return pulumix.Output[FlockerVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated func (o FlockerVolumeSourcePatchOutput) DatasetName() pulumi.StringPtrOutput { return o.ApplyT(func(v FlockerVolumeSourcePatch) *string { return v.DatasetName }).(pulumi.StringPtrOutput) @@ -19682,6 +22293,12 @@ func (o FlockerVolumeSourcePatchPtrOutput) ToFlockerVolumeSourcePatchPtrOutputWi return o } +func (o FlockerVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlockerVolumeSourcePatch] { + return pulumix.Output[*FlockerVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o FlockerVolumeSourcePatchPtrOutput) Elem() FlockerVolumeSourcePatchOutput { return o.ApplyT(func(v *FlockerVolumeSourcePatch) FlockerVolumeSourcePatch { if v != nil { @@ -19763,6 +22380,12 @@ func (i GCEPersistentDiskVolumeSourceArgs) ToGCEPersistentDiskVolumeSourceOutput return pulumi.ToOutputWithContext(ctx, i).(GCEPersistentDiskVolumeSourceOutput) } +func (i GCEPersistentDiskVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[GCEPersistentDiskVolumeSource] { + return pulumix.Output[GCEPersistentDiskVolumeSource]{ + OutputState: i.ToGCEPersistentDiskVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i GCEPersistentDiskVolumeSourceArgs) ToGCEPersistentDiskVolumeSourcePtrOutput() GCEPersistentDiskVolumeSourcePtrOutput { return i.ToGCEPersistentDiskVolumeSourcePtrOutputWithContext(context.Background()) } @@ -19804,6 +22427,12 @@ func (i *gcepersistentDiskVolumeSourcePtrType) ToGCEPersistentDiskVolumeSourcePt return pulumi.ToOutputWithContext(ctx, i).(GCEPersistentDiskVolumeSourcePtrOutput) } +func (i *gcepersistentDiskVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*GCEPersistentDiskVolumeSource] { + return pulumix.Output[*GCEPersistentDiskVolumeSource]{ + OutputState: i.ToGCEPersistentDiskVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Persistent Disk resource in Google Compute Engine. // // A GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling. @@ -19831,6 +22460,12 @@ func (o GCEPersistentDiskVolumeSourceOutput) ToGCEPersistentDiskVolumeSourcePtrO }).(GCEPersistentDiskVolumeSourcePtrOutput) } +func (o GCEPersistentDiskVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[GCEPersistentDiskVolumeSource] { + return pulumix.Output[GCEPersistentDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk func (o GCEPersistentDiskVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v GCEPersistentDiskVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -19865,6 +22500,12 @@ func (o GCEPersistentDiskVolumeSourcePtrOutput) ToGCEPersistentDiskVolumeSourceP return o } +func (o GCEPersistentDiskVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GCEPersistentDiskVolumeSource] { + return pulumix.Output[*GCEPersistentDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o GCEPersistentDiskVolumeSourcePtrOutput) Elem() GCEPersistentDiskVolumeSourceOutput { return o.ApplyT(func(v *GCEPersistentDiskVolumeSource) GCEPersistentDiskVolumeSource { if v != nil { @@ -19966,6 +22607,12 @@ func (i GCEPersistentDiskVolumeSourcePatchArgs) ToGCEPersistentDiskVolumeSourceP return pulumi.ToOutputWithContext(ctx, i).(GCEPersistentDiskVolumeSourcePatchOutput) } +func (i GCEPersistentDiskVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[GCEPersistentDiskVolumeSourcePatch] { + return pulumix.Output[GCEPersistentDiskVolumeSourcePatch]{ + OutputState: i.ToGCEPersistentDiskVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i GCEPersistentDiskVolumeSourcePatchArgs) ToGCEPersistentDiskVolumeSourcePatchPtrOutput() GCEPersistentDiskVolumeSourcePatchPtrOutput { return i.ToGCEPersistentDiskVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -20007,6 +22654,12 @@ func (i *gcepersistentDiskVolumeSourcePatchPtrType) ToGCEPersistentDiskVolumeSou return pulumi.ToOutputWithContext(ctx, i).(GCEPersistentDiskVolumeSourcePatchPtrOutput) } +func (i *gcepersistentDiskVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GCEPersistentDiskVolumeSourcePatch] { + return pulumix.Output[*GCEPersistentDiskVolumeSourcePatch]{ + OutputState: i.ToGCEPersistentDiskVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Persistent Disk resource in Google Compute Engine. // // A GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling. @@ -20034,6 +22687,12 @@ func (o GCEPersistentDiskVolumeSourcePatchOutput) ToGCEPersistentDiskVolumeSourc }).(GCEPersistentDiskVolumeSourcePatchPtrOutput) } +func (o GCEPersistentDiskVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[GCEPersistentDiskVolumeSourcePatch] { + return pulumix.Output[GCEPersistentDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk func (o GCEPersistentDiskVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v GCEPersistentDiskVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -20068,6 +22727,12 @@ func (o GCEPersistentDiskVolumeSourcePatchPtrOutput) ToGCEPersistentDiskVolumeSo return o } +func (o GCEPersistentDiskVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GCEPersistentDiskVolumeSourcePatch] { + return pulumix.Output[*GCEPersistentDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o GCEPersistentDiskVolumeSourcePatchPtrOutput) Elem() GCEPersistentDiskVolumeSourcePatchOutput { return o.ApplyT(func(v *GCEPersistentDiskVolumeSourcePatch) GCEPersistentDiskVolumeSourcePatch { if v != nil { @@ -20159,6 +22824,12 @@ func (i GRPCActionArgs) ToGRPCActionOutputWithContext(ctx context.Context) GRPCA return pulumi.ToOutputWithContext(ctx, i).(GRPCActionOutput) } +func (i GRPCActionArgs) ToOutput(ctx context.Context) pulumix.Output[GRPCAction] { + return pulumix.Output[GRPCAction]{ + OutputState: i.ToGRPCActionOutputWithContext(ctx).OutputState, + } +} + func (i GRPCActionArgs) ToGRPCActionPtrOutput() GRPCActionPtrOutput { return i.ToGRPCActionPtrOutputWithContext(context.Background()) } @@ -20200,6 +22871,12 @@ func (i *grpcactionPtrType) ToGRPCActionPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(GRPCActionPtrOutput) } +func (i *grpcactionPtrType) ToOutput(ctx context.Context) pulumix.Output[*GRPCAction] { + return pulumix.Output[*GRPCAction]{ + OutputState: i.ToGRPCActionPtrOutputWithContext(ctx).OutputState, + } +} + type GRPCActionOutput struct{ *pulumi.OutputState } func (GRPCActionOutput) ElementType() reflect.Type { @@ -20224,6 +22901,12 @@ func (o GRPCActionOutput) ToGRPCActionPtrOutputWithContext(ctx context.Context) }).(GRPCActionPtrOutput) } +func (o GRPCActionOutput) ToOutput(ctx context.Context) pulumix.Output[GRPCAction] { + return pulumix.Output[GRPCAction]{ + OutputState: o.OutputState, + } +} + // Port number of the gRPC service. Number must be in the range 1 to 65535. func (o GRPCActionOutput) Port() pulumi.IntOutput { return o.ApplyT(func(v GRPCAction) int { return v.Port }).(pulumi.IntOutput) @@ -20250,6 +22933,12 @@ func (o GRPCActionPtrOutput) ToGRPCActionPtrOutputWithContext(ctx context.Contex return o } +func (o GRPCActionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GRPCAction] { + return pulumix.Output[*GRPCAction]{ + OutputState: o.OutputState, + } +} + func (o GRPCActionPtrOutput) Elem() GRPCActionOutput { return o.ApplyT(func(v *GRPCAction) GRPCAction { if v != nil { @@ -20323,6 +23012,12 @@ func (i GRPCActionPatchArgs) ToGRPCActionPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(GRPCActionPatchOutput) } +func (i GRPCActionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[GRPCActionPatch] { + return pulumix.Output[GRPCActionPatch]{ + OutputState: i.ToGRPCActionPatchOutputWithContext(ctx).OutputState, + } +} + func (i GRPCActionPatchArgs) ToGRPCActionPatchPtrOutput() GRPCActionPatchPtrOutput { return i.ToGRPCActionPatchPtrOutputWithContext(context.Background()) } @@ -20364,6 +23059,12 @@ func (i *grpcactionPatchPtrType) ToGRPCActionPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(GRPCActionPatchPtrOutput) } +func (i *grpcactionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GRPCActionPatch] { + return pulumix.Output[*GRPCActionPatch]{ + OutputState: i.ToGRPCActionPatchPtrOutputWithContext(ctx).OutputState, + } +} + type GRPCActionPatchOutput struct{ *pulumi.OutputState } func (GRPCActionPatchOutput) ElementType() reflect.Type { @@ -20388,6 +23089,12 @@ func (o GRPCActionPatchOutput) ToGRPCActionPatchPtrOutputWithContext(ctx context }).(GRPCActionPatchPtrOutput) } +func (o GRPCActionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[GRPCActionPatch] { + return pulumix.Output[GRPCActionPatch]{ + OutputState: o.OutputState, + } +} + // Port number of the gRPC service. Number must be in the range 1 to 65535. func (o GRPCActionPatchOutput) Port() pulumi.IntPtrOutput { return o.ApplyT(func(v GRPCActionPatch) *int { return v.Port }).(pulumi.IntPtrOutput) @@ -20414,6 +23121,12 @@ func (o GRPCActionPatchPtrOutput) ToGRPCActionPatchPtrOutputWithContext(ctx cont return o } +func (o GRPCActionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GRPCActionPatch] { + return pulumix.Output[*GRPCActionPatch]{ + OutputState: o.OutputState, + } +} + func (o GRPCActionPatchPtrOutput) Elem() GRPCActionPatchOutput { return o.ApplyT(func(v *GRPCActionPatch) GRPCActionPatch { if v != nil { @@ -20493,6 +23206,12 @@ func (i GitRepoVolumeSourceArgs) ToGitRepoVolumeSourceOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(GitRepoVolumeSourceOutput) } +func (i GitRepoVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[GitRepoVolumeSource] { + return pulumix.Output[GitRepoVolumeSource]{ + OutputState: i.ToGitRepoVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i GitRepoVolumeSourceArgs) ToGitRepoVolumeSourcePtrOutput() GitRepoVolumeSourcePtrOutput { return i.ToGitRepoVolumeSourcePtrOutputWithContext(context.Background()) } @@ -20534,6 +23253,12 @@ func (i *gitRepoVolumeSourcePtrType) ToGitRepoVolumeSourcePtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(GitRepoVolumeSourcePtrOutput) } +func (i *gitRepoVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*GitRepoVolumeSource] { + return pulumix.Output[*GitRepoVolumeSource]{ + OutputState: i.ToGitRepoVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling. // // DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container. @@ -20561,6 +23286,12 @@ func (o GitRepoVolumeSourceOutput) ToGitRepoVolumeSourcePtrOutputWithContext(ctx }).(GitRepoVolumeSourcePtrOutput) } +func (o GitRepoVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[GitRepoVolumeSource] { + return pulumix.Output[GitRepoVolumeSource]{ + OutputState: o.OutputState, + } +} + // directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name. func (o GitRepoVolumeSourceOutput) Directory() pulumi.StringPtrOutput { return o.ApplyT(func(v GitRepoVolumeSource) *string { return v.Directory }).(pulumi.StringPtrOutput) @@ -20590,6 +23321,12 @@ func (o GitRepoVolumeSourcePtrOutput) ToGitRepoVolumeSourcePtrOutputWithContext( return o } +func (o GitRepoVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GitRepoVolumeSource] { + return pulumix.Output[*GitRepoVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o GitRepoVolumeSourcePtrOutput) Elem() GitRepoVolumeSourceOutput { return o.ApplyT(func(v *GitRepoVolumeSource) GitRepoVolumeSource { if v != nil { @@ -20677,6 +23414,12 @@ func (i GitRepoVolumeSourcePatchArgs) ToGitRepoVolumeSourcePatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(GitRepoVolumeSourcePatchOutput) } +func (i GitRepoVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[GitRepoVolumeSourcePatch] { + return pulumix.Output[GitRepoVolumeSourcePatch]{ + OutputState: i.ToGitRepoVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i GitRepoVolumeSourcePatchArgs) ToGitRepoVolumeSourcePatchPtrOutput() GitRepoVolumeSourcePatchPtrOutput { return i.ToGitRepoVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -20718,6 +23461,12 @@ func (i *gitRepoVolumeSourcePatchPtrType) ToGitRepoVolumeSourcePatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(GitRepoVolumeSourcePatchPtrOutput) } +func (i *gitRepoVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GitRepoVolumeSourcePatch] { + return pulumix.Output[*GitRepoVolumeSourcePatch]{ + OutputState: i.ToGitRepoVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling. // // DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container. @@ -20745,6 +23494,12 @@ func (o GitRepoVolumeSourcePatchOutput) ToGitRepoVolumeSourcePatchPtrOutputWithC }).(GitRepoVolumeSourcePatchPtrOutput) } +func (o GitRepoVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[GitRepoVolumeSourcePatch] { + return pulumix.Output[GitRepoVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name. func (o GitRepoVolumeSourcePatchOutput) Directory() pulumi.StringPtrOutput { return o.ApplyT(func(v GitRepoVolumeSourcePatch) *string { return v.Directory }).(pulumi.StringPtrOutput) @@ -20774,6 +23529,12 @@ func (o GitRepoVolumeSourcePatchPtrOutput) ToGitRepoVolumeSourcePatchPtrOutputWi return o } +func (o GitRepoVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GitRepoVolumeSourcePatch] { + return pulumix.Output[*GitRepoVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o GitRepoVolumeSourcePatchPtrOutput) Elem() GitRepoVolumeSourcePatchOutput { return o.ApplyT(func(v *GitRepoVolumeSourcePatch) GitRepoVolumeSourcePatch { if v != nil { @@ -20861,6 +23622,12 @@ func (i GlusterfsPersistentVolumeSourceArgs) ToGlusterfsPersistentVolumeSourceOu return pulumi.ToOutputWithContext(ctx, i).(GlusterfsPersistentVolumeSourceOutput) } +func (i GlusterfsPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[GlusterfsPersistentVolumeSource] { + return pulumix.Output[GlusterfsPersistentVolumeSource]{ + OutputState: i.ToGlusterfsPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i GlusterfsPersistentVolumeSourceArgs) ToGlusterfsPersistentVolumeSourcePtrOutput() GlusterfsPersistentVolumeSourcePtrOutput { return i.ToGlusterfsPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -20902,6 +23669,12 @@ func (i *glusterfsPersistentVolumeSourcePtrType) ToGlusterfsPersistentVolumeSour return pulumi.ToOutputWithContext(ctx, i).(GlusterfsPersistentVolumeSourcePtrOutput) } +func (i *glusterfsPersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsPersistentVolumeSource] { + return pulumix.Output[*GlusterfsPersistentVolumeSource]{ + OutputState: i.ToGlusterfsPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. type GlusterfsPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -20927,6 +23700,12 @@ func (o GlusterfsPersistentVolumeSourceOutput) ToGlusterfsPersistentVolumeSource }).(GlusterfsPersistentVolumeSourcePtrOutput) } +func (o GlusterfsPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[GlusterfsPersistentVolumeSource] { + return pulumix.Output[GlusterfsPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod func (o GlusterfsPersistentVolumeSourceOutput) Endpoints() pulumi.StringOutput { return o.ApplyT(func(v GlusterfsPersistentVolumeSource) string { return v.Endpoints }).(pulumi.StringOutput) @@ -20961,6 +23740,12 @@ func (o GlusterfsPersistentVolumeSourcePtrOutput) ToGlusterfsPersistentVolumeSou return o } +func (o GlusterfsPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsPersistentVolumeSource] { + return pulumix.Output[*GlusterfsPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o GlusterfsPersistentVolumeSourcePtrOutput) Elem() GlusterfsPersistentVolumeSourceOutput { return o.ApplyT(func(v *GlusterfsPersistentVolumeSource) GlusterfsPersistentVolumeSource { if v != nil { @@ -21058,6 +23843,12 @@ func (i GlusterfsPersistentVolumeSourcePatchArgs) ToGlusterfsPersistentVolumeSou return pulumi.ToOutputWithContext(ctx, i).(GlusterfsPersistentVolumeSourcePatchOutput) } +func (i GlusterfsPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[GlusterfsPersistentVolumeSourcePatch] { + return pulumix.Output[GlusterfsPersistentVolumeSourcePatch]{ + OutputState: i.ToGlusterfsPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i GlusterfsPersistentVolumeSourcePatchArgs) ToGlusterfsPersistentVolumeSourcePatchPtrOutput() GlusterfsPersistentVolumeSourcePatchPtrOutput { return i.ToGlusterfsPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -21099,6 +23890,12 @@ func (i *glusterfsPersistentVolumeSourcePatchPtrType) ToGlusterfsPersistentVolum return pulumi.ToOutputWithContext(ctx, i).(GlusterfsPersistentVolumeSourcePatchPtrOutput) } +func (i *glusterfsPersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsPersistentVolumeSourcePatch] { + return pulumix.Output[*GlusterfsPersistentVolumeSourcePatch]{ + OutputState: i.ToGlusterfsPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. type GlusterfsPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -21124,6 +23921,12 @@ func (o GlusterfsPersistentVolumeSourcePatchOutput) ToGlusterfsPersistentVolumeS }).(GlusterfsPersistentVolumeSourcePatchPtrOutput) } +func (o GlusterfsPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[GlusterfsPersistentVolumeSourcePatch] { + return pulumix.Output[GlusterfsPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod func (o GlusterfsPersistentVolumeSourcePatchOutput) Endpoints() pulumi.StringPtrOutput { return o.ApplyT(func(v GlusterfsPersistentVolumeSourcePatch) *string { return v.Endpoints }).(pulumi.StringPtrOutput) @@ -21158,6 +23961,12 @@ func (o GlusterfsPersistentVolumeSourcePatchPtrOutput) ToGlusterfsPersistentVolu return o } +func (o GlusterfsPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsPersistentVolumeSourcePatch] { + return pulumix.Output[*GlusterfsPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o GlusterfsPersistentVolumeSourcePatchPtrOutput) Elem() GlusterfsPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *GlusterfsPersistentVolumeSourcePatch) GlusterfsPersistentVolumeSourcePatch { if v != nil { @@ -21251,6 +24060,12 @@ func (i GlusterfsVolumeSourceArgs) ToGlusterfsVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(GlusterfsVolumeSourceOutput) } +func (i GlusterfsVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[GlusterfsVolumeSource] { + return pulumix.Output[GlusterfsVolumeSource]{ + OutputState: i.ToGlusterfsVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i GlusterfsVolumeSourceArgs) ToGlusterfsVolumeSourcePtrOutput() GlusterfsVolumeSourcePtrOutput { return i.ToGlusterfsVolumeSourcePtrOutputWithContext(context.Background()) } @@ -21292,6 +24107,12 @@ func (i *glusterfsVolumeSourcePtrType) ToGlusterfsVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(GlusterfsVolumeSourcePtrOutput) } +func (i *glusterfsVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsVolumeSource] { + return pulumix.Output[*GlusterfsVolumeSource]{ + OutputState: i.ToGlusterfsVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. type GlusterfsVolumeSourceOutput struct{ *pulumi.OutputState } @@ -21317,6 +24138,12 @@ func (o GlusterfsVolumeSourceOutput) ToGlusterfsVolumeSourcePtrOutputWithContext }).(GlusterfsVolumeSourcePtrOutput) } +func (o GlusterfsVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[GlusterfsVolumeSource] { + return pulumix.Output[GlusterfsVolumeSource]{ + OutputState: o.OutputState, + } +} + // endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod func (o GlusterfsVolumeSourceOutput) Endpoints() pulumi.StringOutput { return o.ApplyT(func(v GlusterfsVolumeSource) string { return v.Endpoints }).(pulumi.StringOutput) @@ -21346,6 +24173,12 @@ func (o GlusterfsVolumeSourcePtrOutput) ToGlusterfsVolumeSourcePtrOutputWithCont return o } +func (o GlusterfsVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsVolumeSource] { + return pulumix.Output[*GlusterfsVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o GlusterfsVolumeSourcePtrOutput) Elem() GlusterfsVolumeSourceOutput { return o.ApplyT(func(v *GlusterfsVolumeSource) GlusterfsVolumeSource { if v != nil { @@ -21429,6 +24262,12 @@ func (i GlusterfsVolumeSourcePatchArgs) ToGlusterfsVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(GlusterfsVolumeSourcePatchOutput) } +func (i GlusterfsVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[GlusterfsVolumeSourcePatch] { + return pulumix.Output[GlusterfsVolumeSourcePatch]{ + OutputState: i.ToGlusterfsVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i GlusterfsVolumeSourcePatchArgs) ToGlusterfsVolumeSourcePatchPtrOutput() GlusterfsVolumeSourcePatchPtrOutput { return i.ToGlusterfsVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -21470,6 +24309,12 @@ func (i *glusterfsVolumeSourcePatchPtrType) ToGlusterfsVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(GlusterfsVolumeSourcePatchPtrOutput) } +func (i *glusterfsVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsVolumeSourcePatch] { + return pulumix.Output[*GlusterfsVolumeSourcePatch]{ + OutputState: i.ToGlusterfsVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. type GlusterfsVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -21495,6 +24340,12 @@ func (o GlusterfsVolumeSourcePatchOutput) ToGlusterfsVolumeSourcePatchPtrOutputW }).(GlusterfsVolumeSourcePatchPtrOutput) } +func (o GlusterfsVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[GlusterfsVolumeSourcePatch] { + return pulumix.Output[GlusterfsVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod func (o GlusterfsVolumeSourcePatchOutput) Endpoints() pulumi.StringPtrOutput { return o.ApplyT(func(v GlusterfsVolumeSourcePatch) *string { return v.Endpoints }).(pulumi.StringPtrOutput) @@ -21524,6 +24375,12 @@ func (o GlusterfsVolumeSourcePatchPtrOutput) ToGlusterfsVolumeSourcePatchPtrOutp return o } +func (o GlusterfsVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GlusterfsVolumeSourcePatch] { + return pulumix.Output[*GlusterfsVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o GlusterfsVolumeSourcePatchPtrOutput) Elem() GlusterfsVolumeSourcePatchOutput { return o.ApplyT(func(v *GlusterfsVolumeSourcePatch) GlusterfsVolumeSourcePatch { if v != nil { @@ -21615,6 +24472,12 @@ func (i HTTPGetActionArgs) ToHTTPGetActionOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(HTTPGetActionOutput) } +func (i HTTPGetActionArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPGetAction] { + return pulumix.Output[HTTPGetAction]{ + OutputState: i.ToHTTPGetActionOutputWithContext(ctx).OutputState, + } +} + func (i HTTPGetActionArgs) ToHTTPGetActionPtrOutput() HTTPGetActionPtrOutput { return i.ToHTTPGetActionPtrOutputWithContext(context.Background()) } @@ -21656,6 +24519,12 @@ func (i *httpgetActionPtrType) ToHTTPGetActionPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(HTTPGetActionPtrOutput) } +func (i *httpgetActionPtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPGetAction] { + return pulumix.Output[*HTTPGetAction]{ + OutputState: i.ToHTTPGetActionPtrOutputWithContext(ctx).OutputState, + } +} + // HTTPGetAction describes an action based on HTTP Get requests. type HTTPGetActionOutput struct{ *pulumi.OutputState } @@ -21681,6 +24550,12 @@ func (o HTTPGetActionOutput) ToHTTPGetActionPtrOutputWithContext(ctx context.Con }).(HTTPGetActionPtrOutput) } +func (o HTTPGetActionOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPGetAction] { + return pulumix.Output[HTTPGetAction]{ + OutputState: o.OutputState, + } +} + // Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. func (o HTTPGetActionOutput) Host() pulumi.StringPtrOutput { return o.ApplyT(func(v HTTPGetAction) *string { return v.Host }).(pulumi.StringPtrOutput) @@ -21720,6 +24595,12 @@ func (o HTTPGetActionPtrOutput) ToHTTPGetActionPtrOutputWithContext(ctx context. return o } +func (o HTTPGetActionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPGetAction] { + return pulumix.Output[*HTTPGetAction]{ + OutputState: o.OutputState, + } +} + func (o HTTPGetActionPtrOutput) Elem() HTTPGetActionOutput { return o.ApplyT(func(v *HTTPGetAction) HTTPGetAction { if v != nil { @@ -21831,6 +24712,12 @@ func (i HTTPGetActionPatchArgs) ToHTTPGetActionPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HTTPGetActionPatchOutput) } +func (i HTTPGetActionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPGetActionPatch] { + return pulumix.Output[HTTPGetActionPatch]{ + OutputState: i.ToHTTPGetActionPatchOutputWithContext(ctx).OutputState, + } +} + func (i HTTPGetActionPatchArgs) ToHTTPGetActionPatchPtrOutput() HTTPGetActionPatchPtrOutput { return i.ToHTTPGetActionPatchPtrOutputWithContext(context.Background()) } @@ -21872,6 +24759,12 @@ func (i *httpgetActionPatchPtrType) ToHTTPGetActionPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HTTPGetActionPatchPtrOutput) } +func (i *httpgetActionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPGetActionPatch] { + return pulumix.Output[*HTTPGetActionPatch]{ + OutputState: i.ToHTTPGetActionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // HTTPGetAction describes an action based on HTTP Get requests. type HTTPGetActionPatchOutput struct{ *pulumi.OutputState } @@ -21897,6 +24790,12 @@ func (o HTTPGetActionPatchOutput) ToHTTPGetActionPatchPtrOutputWithContext(ctx c }).(HTTPGetActionPatchPtrOutput) } +func (o HTTPGetActionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPGetActionPatch] { + return pulumix.Output[HTTPGetActionPatch]{ + OutputState: o.OutputState, + } +} + // Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. func (o HTTPGetActionPatchOutput) Host() pulumi.StringPtrOutput { return o.ApplyT(func(v HTTPGetActionPatch) *string { return v.Host }).(pulumi.StringPtrOutput) @@ -21936,6 +24835,12 @@ func (o HTTPGetActionPatchPtrOutput) ToHTTPGetActionPatchPtrOutputWithContext(ct return o } +func (o HTTPGetActionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPGetActionPatch] { + return pulumix.Output[*HTTPGetActionPatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPGetActionPatchPtrOutput) Elem() HTTPGetActionPatchOutput { return o.ApplyT(func(v *HTTPGetActionPatch) HTTPGetActionPatch { if v != nil { @@ -22035,6 +24940,12 @@ func (i HTTPHeaderArgs) ToHTTPHeaderOutputWithContext(ctx context.Context) HTTPH return pulumi.ToOutputWithContext(ctx, i).(HTTPHeaderOutput) } +func (i HTTPHeaderArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPHeader] { + return pulumix.Output[HTTPHeader]{ + OutputState: i.ToHTTPHeaderOutputWithContext(ctx).OutputState, + } +} + // HTTPHeaderArrayInput is an input type that accepts HTTPHeaderArray and HTTPHeaderArrayOutput values. // You can construct a concrete instance of `HTTPHeaderArrayInput` via: // @@ -22060,6 +24971,12 @@ func (i HTTPHeaderArray) ToHTTPHeaderArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(HTTPHeaderArrayOutput) } +func (i HTTPHeaderArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPHeader] { + return pulumix.Output[[]HTTPHeader]{ + OutputState: i.ToHTTPHeaderArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPHeader describes a custom header to be used in HTTP probes type HTTPHeaderOutput struct{ *pulumi.OutputState } @@ -22075,6 +24992,12 @@ func (o HTTPHeaderOutput) ToHTTPHeaderOutputWithContext(ctx context.Context) HTT return o } +func (o HTTPHeaderOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPHeader] { + return pulumix.Output[HTTPHeader]{ + OutputState: o.OutputState, + } +} + // The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header. func (o HTTPHeaderOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v HTTPHeader) string { return v.Name }).(pulumi.StringOutput) @@ -22099,6 +25022,12 @@ func (o HTTPHeaderArrayOutput) ToHTTPHeaderArrayOutputWithContext(ctx context.Co return o } +func (o HTTPHeaderArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPHeader] { + return pulumix.Output[[]HTTPHeader]{ + OutputState: o.OutputState, + } +} + func (o HTTPHeaderArrayOutput) Index(i pulumi.IntInput) HTTPHeaderOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPHeader { return vs[0].([]HTTPHeader)[vs[1].(int)] @@ -22144,6 +25073,12 @@ func (i HTTPHeaderPatchArgs) ToHTTPHeaderPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(HTTPHeaderPatchOutput) } +func (i HTTPHeaderPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPHeaderPatch] { + return pulumix.Output[HTTPHeaderPatch]{ + OutputState: i.ToHTTPHeaderPatchOutputWithContext(ctx).OutputState, + } +} + // HTTPHeaderPatchArrayInput is an input type that accepts HTTPHeaderPatchArray and HTTPHeaderPatchArrayOutput values. // You can construct a concrete instance of `HTTPHeaderPatchArrayInput` via: // @@ -22169,6 +25104,12 @@ func (i HTTPHeaderPatchArray) ToHTTPHeaderPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HTTPHeaderPatchArrayOutput) } +func (i HTTPHeaderPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPHeaderPatch] { + return pulumix.Output[[]HTTPHeaderPatch]{ + OutputState: i.ToHTTPHeaderPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPHeader describes a custom header to be used in HTTP probes type HTTPHeaderPatchOutput struct{ *pulumi.OutputState } @@ -22184,6 +25125,12 @@ func (o HTTPHeaderPatchOutput) ToHTTPHeaderPatchOutputWithContext(ctx context.Co return o } +func (o HTTPHeaderPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPHeaderPatch] { + return pulumix.Output[HTTPHeaderPatch]{ + OutputState: o.OutputState, + } +} + // The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header. func (o HTTPHeaderPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v HTTPHeaderPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -22208,6 +25155,12 @@ func (o HTTPHeaderPatchArrayOutput) ToHTTPHeaderPatchArrayOutputWithContext(ctx return o } +func (o HTTPHeaderPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPHeaderPatch] { + return pulumix.Output[[]HTTPHeaderPatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPHeaderPatchArrayOutput) Index(i pulumi.IntInput) HTTPHeaderPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPHeaderPatch { return vs[0].([]HTTPHeaderPatch)[vs[1].(int)] @@ -22257,6 +25210,12 @@ func (i HandlerArgs) ToHandlerOutputWithContext(ctx context.Context) HandlerOutp return pulumi.ToOutputWithContext(ctx, i).(HandlerOutput) } +func (i HandlerArgs) ToOutput(ctx context.Context) pulumix.Output[Handler] { + return pulumix.Output[Handler]{ + OutputState: i.ToHandlerOutputWithContext(ctx).OutputState, + } +} + // Handler defines a specific action that should be taken type HandlerOutput struct{ *pulumi.OutputState } @@ -22272,6 +25231,12 @@ func (o HandlerOutput) ToHandlerOutputWithContext(ctx context.Context) HandlerOu return o } +func (o HandlerOutput) ToOutput(ctx context.Context) pulumix.Output[Handler] { + return pulumix.Output[Handler]{ + OutputState: o.OutputState, + } +} + // One and only one of the following should be specified. Exec specifies the action to take. func (o HandlerOutput) Exec() ExecActionPtrOutput { return o.ApplyT(func(v Handler) *ExecAction { return v.Exec }).(ExecActionPtrOutput) @@ -22330,6 +25295,12 @@ func (i HandlerPatchArgs) ToHandlerPatchOutputWithContext(ctx context.Context) H return pulumi.ToOutputWithContext(ctx, i).(HandlerPatchOutput) } +func (i HandlerPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HandlerPatch] { + return pulumix.Output[HandlerPatch]{ + OutputState: i.ToHandlerPatchOutputWithContext(ctx).OutputState, + } +} + // Handler defines a specific action that should be taken type HandlerPatchOutput struct{ *pulumi.OutputState } @@ -22345,6 +25316,12 @@ func (o HandlerPatchOutput) ToHandlerPatchOutputWithContext(ctx context.Context) return o } +func (o HandlerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HandlerPatch] { + return pulumix.Output[HandlerPatch]{ + OutputState: o.OutputState, + } +} + // One and only one of the following should be specified. Exec specifies the action to take. func (o HandlerPatchOutput) Exec() ExecActionPatchPtrOutput { return o.ApplyT(func(v HandlerPatch) *ExecActionPatch { return v.Exec }).(ExecActionPatchPtrOutput) @@ -22399,6 +25376,12 @@ func (i HostAliasArgs) ToHostAliasOutputWithContext(ctx context.Context) HostAli return pulumi.ToOutputWithContext(ctx, i).(HostAliasOutput) } +func (i HostAliasArgs) ToOutput(ctx context.Context) pulumix.Output[HostAlias] { + return pulumix.Output[HostAlias]{ + OutputState: i.ToHostAliasOutputWithContext(ctx).OutputState, + } +} + // HostAliasArrayInput is an input type that accepts HostAliasArray and HostAliasArrayOutput values. // You can construct a concrete instance of `HostAliasArrayInput` via: // @@ -22424,6 +25407,12 @@ func (i HostAliasArray) ToHostAliasArrayOutputWithContext(ctx context.Context) H return pulumi.ToOutputWithContext(ctx, i).(HostAliasArrayOutput) } +func (i HostAliasArray) ToOutput(ctx context.Context) pulumix.Output[[]HostAlias] { + return pulumix.Output[[]HostAlias]{ + OutputState: i.ToHostAliasArrayOutputWithContext(ctx).OutputState, + } +} + // HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file. type HostAliasOutput struct{ *pulumi.OutputState } @@ -22439,6 +25428,12 @@ func (o HostAliasOutput) ToHostAliasOutputWithContext(ctx context.Context) HostA return o } +func (o HostAliasOutput) ToOutput(ctx context.Context) pulumix.Output[HostAlias] { + return pulumix.Output[HostAlias]{ + OutputState: o.OutputState, + } +} + // Hostnames for the above IP address. func (o HostAliasOutput) Hostnames() pulumi.StringArrayOutput { return o.ApplyT(func(v HostAlias) []string { return v.Hostnames }).(pulumi.StringArrayOutput) @@ -22463,6 +25458,12 @@ func (o HostAliasArrayOutput) ToHostAliasArrayOutputWithContext(ctx context.Cont return o } +func (o HostAliasArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostAlias] { + return pulumix.Output[[]HostAlias]{ + OutputState: o.OutputState, + } +} + func (o HostAliasArrayOutput) Index(i pulumi.IntInput) HostAliasOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostAlias { return vs[0].([]HostAlias)[vs[1].(int)] @@ -22508,6 +25509,12 @@ func (i HostAliasPatchArgs) ToHostAliasPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(HostAliasPatchOutput) } +func (i HostAliasPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HostAliasPatch] { + return pulumix.Output[HostAliasPatch]{ + OutputState: i.ToHostAliasPatchOutputWithContext(ctx).OutputState, + } +} + // HostAliasPatchArrayInput is an input type that accepts HostAliasPatchArray and HostAliasPatchArrayOutput values. // You can construct a concrete instance of `HostAliasPatchArrayInput` via: // @@ -22533,6 +25540,12 @@ func (i HostAliasPatchArray) ToHostAliasPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(HostAliasPatchArrayOutput) } +func (i HostAliasPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HostAliasPatch] { + return pulumix.Output[[]HostAliasPatch]{ + OutputState: i.ToHostAliasPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file. type HostAliasPatchOutput struct{ *pulumi.OutputState } @@ -22548,6 +25561,12 @@ func (o HostAliasPatchOutput) ToHostAliasPatchOutputWithContext(ctx context.Cont return o } +func (o HostAliasPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HostAliasPatch] { + return pulumix.Output[HostAliasPatch]{ + OutputState: o.OutputState, + } +} + // Hostnames for the above IP address. func (o HostAliasPatchOutput) Hostnames() pulumi.StringArrayOutput { return o.ApplyT(func(v HostAliasPatch) []string { return v.Hostnames }).(pulumi.StringArrayOutput) @@ -22572,6 +25591,12 @@ func (o HostAliasPatchArrayOutput) ToHostAliasPatchArrayOutputWithContext(ctx co return o } +func (o HostAliasPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostAliasPatch] { + return pulumix.Output[[]HostAliasPatch]{ + OutputState: o.OutputState, + } +} + func (o HostAliasPatchArrayOutput) Index(i pulumi.IntInput) HostAliasPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostAliasPatch { return vs[0].([]HostAliasPatch)[vs[1].(int)] @@ -22613,6 +25638,12 @@ func (i HostIPArgs) ToHostIPOutputWithContext(ctx context.Context) HostIPOutput return pulumi.ToOutputWithContext(ctx, i).(HostIPOutput) } +func (i HostIPArgs) ToOutput(ctx context.Context) pulumix.Output[HostIP] { + return pulumix.Output[HostIP]{ + OutputState: i.ToHostIPOutputWithContext(ctx).OutputState, + } +} + // HostIPArrayInput is an input type that accepts HostIPArray and HostIPArrayOutput values. // You can construct a concrete instance of `HostIPArrayInput` via: // @@ -22638,6 +25669,12 @@ func (i HostIPArray) ToHostIPArrayOutputWithContext(ctx context.Context) HostIPA return pulumi.ToOutputWithContext(ctx, i).(HostIPArrayOutput) } +func (i HostIPArray) ToOutput(ctx context.Context) pulumix.Output[[]HostIP] { + return pulumix.Output[[]HostIP]{ + OutputState: i.ToHostIPArrayOutputWithContext(ctx).OutputState, + } +} + // HostIP represents a single IP address allocated to the host. type HostIPOutput struct{ *pulumi.OutputState } @@ -22653,6 +25690,12 @@ func (o HostIPOutput) ToHostIPOutputWithContext(ctx context.Context) HostIPOutpu return o } +func (o HostIPOutput) ToOutput(ctx context.Context) pulumix.Output[HostIP] { + return pulumix.Output[HostIP]{ + OutputState: o.OutputState, + } +} + // IP is the IP address assigned to the host func (o HostIPOutput) Ip() pulumi.StringPtrOutput { return o.ApplyT(func(v HostIP) *string { return v.Ip }).(pulumi.StringPtrOutput) @@ -22672,6 +25715,12 @@ func (o HostIPArrayOutput) ToHostIPArrayOutputWithContext(ctx context.Context) H return o } +func (o HostIPArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostIP] { + return pulumix.Output[[]HostIP]{ + OutputState: o.OutputState, + } +} + func (o HostIPArrayOutput) Index(i pulumi.IntInput) HostIPOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostIP { return vs[0].([]HostIP)[vs[1].(int)] @@ -22713,6 +25762,12 @@ func (i HostIPPatchArgs) ToHostIPPatchOutputWithContext(ctx context.Context) Hos return pulumi.ToOutputWithContext(ctx, i).(HostIPPatchOutput) } +func (i HostIPPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HostIPPatch] { + return pulumix.Output[HostIPPatch]{ + OutputState: i.ToHostIPPatchOutputWithContext(ctx).OutputState, + } +} + // HostIPPatchArrayInput is an input type that accepts HostIPPatchArray and HostIPPatchArrayOutput values. // You can construct a concrete instance of `HostIPPatchArrayInput` via: // @@ -22738,6 +25793,12 @@ func (i HostIPPatchArray) ToHostIPPatchArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(HostIPPatchArrayOutput) } +func (i HostIPPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HostIPPatch] { + return pulumix.Output[[]HostIPPatch]{ + OutputState: i.ToHostIPPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HostIP represents a single IP address allocated to the host. type HostIPPatchOutput struct{ *pulumi.OutputState } @@ -22753,6 +25814,12 @@ func (o HostIPPatchOutput) ToHostIPPatchOutputWithContext(ctx context.Context) H return o } +func (o HostIPPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HostIPPatch] { + return pulumix.Output[HostIPPatch]{ + OutputState: o.OutputState, + } +} + // IP is the IP address assigned to the host func (o HostIPPatchOutput) Ip() pulumi.StringPtrOutput { return o.ApplyT(func(v HostIPPatch) *string { return v.Ip }).(pulumi.StringPtrOutput) @@ -22772,6 +25839,12 @@ func (o HostIPPatchArrayOutput) ToHostIPPatchArrayOutputWithContext(ctx context. return o } +func (o HostIPPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostIPPatch] { + return pulumix.Output[[]HostIPPatch]{ + OutputState: o.OutputState, + } +} + func (o HostIPPatchArrayOutput) Index(i pulumi.IntInput) HostIPPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostIPPatch { return vs[0].([]HostIPPatch)[vs[1].(int)] @@ -22817,6 +25890,12 @@ func (i HostPathVolumeSourceArgs) ToHostPathVolumeSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HostPathVolumeSourceOutput) } +func (i HostPathVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[HostPathVolumeSource] { + return pulumix.Output[HostPathVolumeSource]{ + OutputState: i.ToHostPathVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i HostPathVolumeSourceArgs) ToHostPathVolumeSourcePtrOutput() HostPathVolumeSourcePtrOutput { return i.ToHostPathVolumeSourcePtrOutputWithContext(context.Background()) } @@ -22858,6 +25937,12 @@ func (i *hostPathVolumeSourcePtrType) ToHostPathVolumeSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(HostPathVolumeSourcePtrOutput) } +func (i *hostPathVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*HostPathVolumeSource] { + return pulumix.Output[*HostPathVolumeSource]{ + OutputState: i.ToHostPathVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling. type HostPathVolumeSourceOutput struct{ *pulumi.OutputState } @@ -22883,6 +25968,12 @@ func (o HostPathVolumeSourceOutput) ToHostPathVolumeSourcePtrOutputWithContext(c }).(HostPathVolumeSourcePtrOutput) } +func (o HostPathVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[HostPathVolumeSource] { + return pulumix.Output[HostPathVolumeSource]{ + OutputState: o.OutputState, + } +} + // path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath func (o HostPathVolumeSourceOutput) Path() pulumi.StringOutput { return o.ApplyT(func(v HostPathVolumeSource) string { return v.Path }).(pulumi.StringOutput) @@ -22907,6 +25998,12 @@ func (o HostPathVolumeSourcePtrOutput) ToHostPathVolumeSourcePtrOutputWithContex return o } +func (o HostPathVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HostPathVolumeSource] { + return pulumix.Output[*HostPathVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o HostPathVolumeSourcePtrOutput) Elem() HostPathVolumeSourceOutput { return o.ApplyT(func(v *HostPathVolumeSource) HostPathVolumeSource { if v != nil { @@ -22976,6 +26073,12 @@ func (i HostPathVolumeSourcePatchArgs) ToHostPathVolumeSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(HostPathVolumeSourcePatchOutput) } +func (i HostPathVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[HostPathVolumeSourcePatch] { + return pulumix.Output[HostPathVolumeSourcePatch]{ + OutputState: i.ToHostPathVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i HostPathVolumeSourcePatchArgs) ToHostPathVolumeSourcePatchPtrOutput() HostPathVolumeSourcePatchPtrOutput { return i.ToHostPathVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -23017,6 +26120,12 @@ func (i *hostPathVolumeSourcePatchPtrType) ToHostPathVolumeSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(HostPathVolumeSourcePatchPtrOutput) } +func (i *hostPathVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HostPathVolumeSourcePatch] { + return pulumix.Output[*HostPathVolumeSourcePatch]{ + OutputState: i.ToHostPathVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling. type HostPathVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -23042,6 +26151,12 @@ func (o HostPathVolumeSourcePatchOutput) ToHostPathVolumeSourcePatchPtrOutputWit }).(HostPathVolumeSourcePatchPtrOutput) } +func (o HostPathVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[HostPathVolumeSourcePatch] { + return pulumix.Output[HostPathVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath func (o HostPathVolumeSourcePatchOutput) Path() pulumi.StringPtrOutput { return o.ApplyT(func(v HostPathVolumeSourcePatch) *string { return v.Path }).(pulumi.StringPtrOutput) @@ -23066,6 +26181,12 @@ func (o HostPathVolumeSourcePatchPtrOutput) ToHostPathVolumeSourcePatchPtrOutput return o } +func (o HostPathVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HostPathVolumeSourcePatch] { + return pulumix.Output[*HostPathVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o HostPathVolumeSourcePatchPtrOutput) Elem() HostPathVolumeSourcePatchOutput { return o.ApplyT(func(v *HostPathVolumeSourcePatch) HostPathVolumeSourcePatch { if v != nil { @@ -23171,6 +26292,12 @@ func (i ISCSIPersistentVolumeSourceArgs) ToISCSIPersistentVolumeSourceOutputWith return pulumi.ToOutputWithContext(ctx, i).(ISCSIPersistentVolumeSourceOutput) } +func (i ISCSIPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ISCSIPersistentVolumeSource] { + return pulumix.Output[ISCSIPersistentVolumeSource]{ + OutputState: i.ToISCSIPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i ISCSIPersistentVolumeSourceArgs) ToISCSIPersistentVolumeSourcePtrOutput() ISCSIPersistentVolumeSourcePtrOutput { return i.ToISCSIPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -23212,6 +26339,12 @@ func (i *iscsipersistentVolumeSourcePtrType) ToISCSIPersistentVolumeSourcePtrOut return pulumi.ToOutputWithContext(ctx, i).(ISCSIPersistentVolumeSourcePtrOutput) } +func (i *iscsipersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ISCSIPersistentVolumeSource] { + return pulumix.Output[*ISCSIPersistentVolumeSource]{ + OutputState: i.ToISCSIPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. type ISCSIPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -23237,6 +26370,12 @@ func (o ISCSIPersistentVolumeSourceOutput) ToISCSIPersistentVolumeSourcePtrOutpu }).(ISCSIPersistentVolumeSourcePtrOutput) } +func (o ISCSIPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ISCSIPersistentVolumeSource] { + return pulumix.Output[ISCSIPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication func (o ISCSIPersistentVolumeSourceOutput) ChapAuthDiscovery() pulumi.BoolPtrOutput { return o.ApplyT(func(v ISCSIPersistentVolumeSource) *bool { return v.ChapAuthDiscovery }).(pulumi.BoolPtrOutput) @@ -23306,6 +26445,12 @@ func (o ISCSIPersistentVolumeSourcePtrOutput) ToISCSIPersistentVolumeSourcePtrOu return o } +func (o ISCSIPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ISCSIPersistentVolumeSource] { + return pulumix.Output[*ISCSIPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o ISCSIPersistentVolumeSourcePtrOutput) Elem() ISCSIPersistentVolumeSourceOutput { return o.ApplyT(func(v *ISCSIPersistentVolumeSource) ISCSIPersistentVolumeSource { if v != nil { @@ -23501,6 +26646,12 @@ func (i ISCSIPersistentVolumeSourcePatchArgs) ToISCSIPersistentVolumeSourcePatch return pulumi.ToOutputWithContext(ctx, i).(ISCSIPersistentVolumeSourcePatchOutput) } +func (i ISCSIPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ISCSIPersistentVolumeSourcePatch] { + return pulumix.Output[ISCSIPersistentVolumeSourcePatch]{ + OutputState: i.ToISCSIPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ISCSIPersistentVolumeSourcePatchArgs) ToISCSIPersistentVolumeSourcePatchPtrOutput() ISCSIPersistentVolumeSourcePatchPtrOutput { return i.ToISCSIPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -23542,6 +26693,12 @@ func (i *iscsipersistentVolumeSourcePatchPtrType) ToISCSIPersistentVolumeSourceP return pulumi.ToOutputWithContext(ctx, i).(ISCSIPersistentVolumeSourcePatchPtrOutput) } +func (i *iscsipersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ISCSIPersistentVolumeSourcePatch] { + return pulumix.Output[*ISCSIPersistentVolumeSourcePatch]{ + OutputState: i.ToISCSIPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. type ISCSIPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -23567,6 +26724,12 @@ func (o ISCSIPersistentVolumeSourcePatchOutput) ToISCSIPersistentVolumeSourcePat }).(ISCSIPersistentVolumeSourcePatchPtrOutput) } +func (o ISCSIPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ISCSIPersistentVolumeSourcePatch] { + return pulumix.Output[ISCSIPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication func (o ISCSIPersistentVolumeSourcePatchOutput) ChapAuthDiscovery() pulumi.BoolPtrOutput { return o.ApplyT(func(v ISCSIPersistentVolumeSourcePatch) *bool { return v.ChapAuthDiscovery }).(pulumi.BoolPtrOutput) @@ -23636,6 +26799,12 @@ func (o ISCSIPersistentVolumeSourcePatchPtrOutput) ToISCSIPersistentVolumeSource return o } +func (o ISCSIPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ISCSIPersistentVolumeSourcePatch] { + return pulumix.Output[*ISCSIPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ISCSIPersistentVolumeSourcePatchPtrOutput) Elem() ISCSIPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *ISCSIPersistentVolumeSourcePatch) ISCSIPersistentVolumeSourcePatch { if v != nil { @@ -23831,6 +27000,12 @@ func (i ISCSIVolumeSourceArgs) ToISCSIVolumeSourceOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ISCSIVolumeSourceOutput) } +func (i ISCSIVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ISCSIVolumeSource] { + return pulumix.Output[ISCSIVolumeSource]{ + OutputState: i.ToISCSIVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i ISCSIVolumeSourceArgs) ToISCSIVolumeSourcePtrOutput() ISCSIVolumeSourcePtrOutput { return i.ToISCSIVolumeSourcePtrOutputWithContext(context.Background()) } @@ -23872,6 +27047,12 @@ func (i *iscsivolumeSourcePtrType) ToISCSIVolumeSourcePtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ISCSIVolumeSourcePtrOutput) } +func (i *iscsivolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ISCSIVolumeSource] { + return pulumix.Output[*ISCSIVolumeSource]{ + OutputState: i.ToISCSIVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. type ISCSIVolumeSourceOutput struct{ *pulumi.OutputState } @@ -23897,6 +27078,12 @@ func (o ISCSIVolumeSourceOutput) ToISCSIVolumeSourcePtrOutputWithContext(ctx con }).(ISCSIVolumeSourcePtrOutput) } +func (o ISCSIVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ISCSIVolumeSource] { + return pulumix.Output[ISCSIVolumeSource]{ + OutputState: o.OutputState, + } +} + // chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication func (o ISCSIVolumeSourceOutput) ChapAuthDiscovery() pulumi.BoolPtrOutput { return o.ApplyT(func(v ISCSIVolumeSource) *bool { return v.ChapAuthDiscovery }).(pulumi.BoolPtrOutput) @@ -23966,6 +27153,12 @@ func (o ISCSIVolumeSourcePtrOutput) ToISCSIVolumeSourcePtrOutputWithContext(ctx return o } +func (o ISCSIVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ISCSIVolumeSource] { + return pulumix.Output[*ISCSIVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o ISCSIVolumeSourcePtrOutput) Elem() ISCSIVolumeSourceOutput { return o.ApplyT(func(v *ISCSIVolumeSource) ISCSIVolumeSource { if v != nil { @@ -24161,6 +27354,12 @@ func (i ISCSIVolumeSourcePatchArgs) ToISCSIVolumeSourcePatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ISCSIVolumeSourcePatchOutput) } +func (i ISCSIVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ISCSIVolumeSourcePatch] { + return pulumix.Output[ISCSIVolumeSourcePatch]{ + OutputState: i.ToISCSIVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ISCSIVolumeSourcePatchArgs) ToISCSIVolumeSourcePatchPtrOutput() ISCSIVolumeSourcePatchPtrOutput { return i.ToISCSIVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -24202,6 +27401,12 @@ func (i *iscsivolumeSourcePatchPtrType) ToISCSIVolumeSourcePatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(ISCSIVolumeSourcePatchPtrOutput) } +func (i *iscsivolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ISCSIVolumeSourcePatch] { + return pulumix.Output[*ISCSIVolumeSourcePatch]{ + OutputState: i.ToISCSIVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. type ISCSIVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -24227,6 +27432,12 @@ func (o ISCSIVolumeSourcePatchOutput) ToISCSIVolumeSourcePatchPtrOutputWithConte }).(ISCSIVolumeSourcePatchPtrOutput) } +func (o ISCSIVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ISCSIVolumeSourcePatch] { + return pulumix.Output[ISCSIVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication func (o ISCSIVolumeSourcePatchOutput) ChapAuthDiscovery() pulumi.BoolPtrOutput { return o.ApplyT(func(v ISCSIVolumeSourcePatch) *bool { return v.ChapAuthDiscovery }).(pulumi.BoolPtrOutput) @@ -24296,6 +27507,12 @@ func (o ISCSIVolumeSourcePatchPtrOutput) ToISCSIVolumeSourcePatchPtrOutputWithCo return o } +func (o ISCSIVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ISCSIVolumeSourcePatch] { + return pulumix.Output[*ISCSIVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ISCSIVolumeSourcePatchPtrOutput) Elem() ISCSIVolumeSourcePatchOutput { return o.ApplyT(func(v *ISCSIVolumeSourcePatch) ISCSIVolumeSourcePatch { if v != nil { @@ -24459,6 +27676,12 @@ func (i KeyToPathArgs) ToKeyToPathOutputWithContext(ctx context.Context) KeyToPa return pulumi.ToOutputWithContext(ctx, i).(KeyToPathOutput) } +func (i KeyToPathArgs) ToOutput(ctx context.Context) pulumix.Output[KeyToPath] { + return pulumix.Output[KeyToPath]{ + OutputState: i.ToKeyToPathOutputWithContext(ctx).OutputState, + } +} + // KeyToPathArrayInput is an input type that accepts KeyToPathArray and KeyToPathArrayOutput values. // You can construct a concrete instance of `KeyToPathArrayInput` via: // @@ -24484,6 +27707,12 @@ func (i KeyToPathArray) ToKeyToPathArrayOutputWithContext(ctx context.Context) K return pulumi.ToOutputWithContext(ctx, i).(KeyToPathArrayOutput) } +func (i KeyToPathArray) ToOutput(ctx context.Context) pulumix.Output[[]KeyToPath] { + return pulumix.Output[[]KeyToPath]{ + OutputState: i.ToKeyToPathArrayOutputWithContext(ctx).OutputState, + } +} + // Maps a string key to a path within a volume. type KeyToPathOutput struct{ *pulumi.OutputState } @@ -24499,6 +27728,12 @@ func (o KeyToPathOutput) ToKeyToPathOutputWithContext(ctx context.Context) KeyTo return o } +func (o KeyToPathOutput) ToOutput(ctx context.Context) pulumix.Output[KeyToPath] { + return pulumix.Output[KeyToPath]{ + OutputState: o.OutputState, + } +} + // key is the key to project. func (o KeyToPathOutput) Key() pulumi.StringOutput { return o.ApplyT(func(v KeyToPath) string { return v.Key }).(pulumi.StringOutput) @@ -24528,6 +27763,12 @@ func (o KeyToPathArrayOutput) ToKeyToPathArrayOutputWithContext(ctx context.Cont return o } +func (o KeyToPathArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]KeyToPath] { + return pulumix.Output[[]KeyToPath]{ + OutputState: o.OutputState, + } +} + func (o KeyToPathArrayOutput) Index(i pulumi.IntInput) KeyToPathOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) KeyToPath { return vs[0].([]KeyToPath)[vs[1].(int)] @@ -24577,6 +27818,12 @@ func (i KeyToPathPatchArgs) ToKeyToPathPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(KeyToPathPatchOutput) } +func (i KeyToPathPatchArgs) ToOutput(ctx context.Context) pulumix.Output[KeyToPathPatch] { + return pulumix.Output[KeyToPathPatch]{ + OutputState: i.ToKeyToPathPatchOutputWithContext(ctx).OutputState, + } +} + // KeyToPathPatchArrayInput is an input type that accepts KeyToPathPatchArray and KeyToPathPatchArrayOutput values. // You can construct a concrete instance of `KeyToPathPatchArrayInput` via: // @@ -24602,6 +27849,12 @@ func (i KeyToPathPatchArray) ToKeyToPathPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(KeyToPathPatchArrayOutput) } +func (i KeyToPathPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]KeyToPathPatch] { + return pulumix.Output[[]KeyToPathPatch]{ + OutputState: i.ToKeyToPathPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Maps a string key to a path within a volume. type KeyToPathPatchOutput struct{ *pulumi.OutputState } @@ -24617,6 +27870,12 @@ func (o KeyToPathPatchOutput) ToKeyToPathPatchOutputWithContext(ctx context.Cont return o } +func (o KeyToPathPatchOutput) ToOutput(ctx context.Context) pulumix.Output[KeyToPathPatch] { + return pulumix.Output[KeyToPathPatch]{ + OutputState: o.OutputState, + } +} + // key is the key to project. func (o KeyToPathPatchOutput) Key() pulumi.StringPtrOutput { return o.ApplyT(func(v KeyToPathPatch) *string { return v.Key }).(pulumi.StringPtrOutput) @@ -24646,6 +27905,12 @@ func (o KeyToPathPatchArrayOutput) ToKeyToPathPatchArrayOutputWithContext(ctx co return o } +func (o KeyToPathPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]KeyToPathPatch] { + return pulumix.Output[[]KeyToPathPatch]{ + OutputState: o.OutputState, + } +} + func (o KeyToPathPatchArrayOutput) Index(i pulumi.IntInput) KeyToPathPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) KeyToPathPatch { return vs[0].([]KeyToPathPatch)[vs[1].(int)] @@ -24691,6 +27956,12 @@ func (i LifecycleArgs) ToLifecycleOutputWithContext(ctx context.Context) Lifecyc return pulumi.ToOutputWithContext(ctx, i).(LifecycleOutput) } +func (i LifecycleArgs) ToOutput(ctx context.Context) pulumix.Output[Lifecycle] { + return pulumix.Output[Lifecycle]{ + OutputState: i.ToLifecycleOutputWithContext(ctx).OutputState, + } +} + func (i LifecycleArgs) ToLifecyclePtrOutput() LifecyclePtrOutput { return i.ToLifecyclePtrOutputWithContext(context.Background()) } @@ -24732,6 +28003,12 @@ func (i *lifecyclePtrType) ToLifecyclePtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LifecyclePtrOutput) } +func (i *lifecyclePtrType) ToOutput(ctx context.Context) pulumix.Output[*Lifecycle] { + return pulumix.Output[*Lifecycle]{ + OutputState: i.ToLifecyclePtrOutputWithContext(ctx).OutputState, + } +} + // Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted. type LifecycleOutput struct{ *pulumi.OutputState } @@ -24757,6 +28034,12 @@ func (o LifecycleOutput) ToLifecyclePtrOutputWithContext(ctx context.Context) Li }).(LifecyclePtrOutput) } +func (o LifecycleOutput) ToOutput(ctx context.Context) pulumix.Output[Lifecycle] { + return pulumix.Output[Lifecycle]{ + OutputState: o.OutputState, + } +} + // PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks func (o LifecycleOutput) PostStart() LifecycleHandlerPtrOutput { return o.ApplyT(func(v Lifecycle) *LifecycleHandler { return v.PostStart }).(LifecycleHandlerPtrOutput) @@ -24781,6 +28064,12 @@ func (o LifecyclePtrOutput) ToLifecyclePtrOutputWithContext(ctx context.Context) return o } +func (o LifecyclePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Lifecycle] { + return pulumix.Output[*Lifecycle]{ + OutputState: o.OutputState, + } +} + func (o LifecyclePtrOutput) Elem() LifecycleOutput { return o.ApplyT(func(v *Lifecycle) Lifecycle { if v != nil { @@ -24854,6 +28143,12 @@ func (i LifecycleHandlerArgs) ToLifecycleHandlerOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(LifecycleHandlerOutput) } +func (i LifecycleHandlerArgs) ToOutput(ctx context.Context) pulumix.Output[LifecycleHandler] { + return pulumix.Output[LifecycleHandler]{ + OutputState: i.ToLifecycleHandlerOutputWithContext(ctx).OutputState, + } +} + func (i LifecycleHandlerArgs) ToLifecycleHandlerPtrOutput() LifecycleHandlerPtrOutput { return i.ToLifecycleHandlerPtrOutputWithContext(context.Background()) } @@ -24895,6 +28190,12 @@ func (i *lifecycleHandlerPtrType) ToLifecycleHandlerPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(LifecycleHandlerPtrOutput) } +func (i *lifecycleHandlerPtrType) ToOutput(ctx context.Context) pulumix.Output[*LifecycleHandler] { + return pulumix.Output[*LifecycleHandler]{ + OutputState: i.ToLifecycleHandlerPtrOutputWithContext(ctx).OutputState, + } +} + // LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified. type LifecycleHandlerOutput struct{ *pulumi.OutputState } @@ -24920,6 +28221,12 @@ func (o LifecycleHandlerOutput) ToLifecycleHandlerPtrOutputWithContext(ctx conte }).(LifecycleHandlerPtrOutput) } +func (o LifecycleHandlerOutput) ToOutput(ctx context.Context) pulumix.Output[LifecycleHandler] { + return pulumix.Output[LifecycleHandler]{ + OutputState: o.OutputState, + } +} + // Exec specifies the action to take. func (o LifecycleHandlerOutput) Exec() ExecActionPtrOutput { return o.ApplyT(func(v LifecycleHandler) *ExecAction { return v.Exec }).(ExecActionPtrOutput) @@ -24949,6 +28256,12 @@ func (o LifecycleHandlerPtrOutput) ToLifecycleHandlerPtrOutputWithContext(ctx co return o } +func (o LifecycleHandlerPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LifecycleHandler] { + return pulumix.Output[*LifecycleHandler]{ + OutputState: o.OutputState, + } +} + func (o LifecycleHandlerPtrOutput) Elem() LifecycleHandlerOutput { return o.ApplyT(func(v *LifecycleHandler) LifecycleHandler { if v != nil { @@ -25032,6 +28345,12 @@ func (i LifecycleHandlerPatchArgs) ToLifecycleHandlerPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LifecycleHandlerPatchOutput) } +func (i LifecycleHandlerPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LifecycleHandlerPatch] { + return pulumix.Output[LifecycleHandlerPatch]{ + OutputState: i.ToLifecycleHandlerPatchOutputWithContext(ctx).OutputState, + } +} + func (i LifecycleHandlerPatchArgs) ToLifecycleHandlerPatchPtrOutput() LifecycleHandlerPatchPtrOutput { return i.ToLifecycleHandlerPatchPtrOutputWithContext(context.Background()) } @@ -25073,6 +28392,12 @@ func (i *lifecycleHandlerPatchPtrType) ToLifecycleHandlerPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(LifecycleHandlerPatchPtrOutput) } +func (i *lifecycleHandlerPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LifecycleHandlerPatch] { + return pulumix.Output[*LifecycleHandlerPatch]{ + OutputState: i.ToLifecycleHandlerPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified. type LifecycleHandlerPatchOutput struct{ *pulumi.OutputState } @@ -25098,6 +28423,12 @@ func (o LifecycleHandlerPatchOutput) ToLifecycleHandlerPatchPtrOutputWithContext }).(LifecycleHandlerPatchPtrOutput) } +func (o LifecycleHandlerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LifecycleHandlerPatch] { + return pulumix.Output[LifecycleHandlerPatch]{ + OutputState: o.OutputState, + } +} + // Exec specifies the action to take. func (o LifecycleHandlerPatchOutput) Exec() ExecActionPatchPtrOutput { return o.ApplyT(func(v LifecycleHandlerPatch) *ExecActionPatch { return v.Exec }).(ExecActionPatchPtrOutput) @@ -25127,6 +28458,12 @@ func (o LifecycleHandlerPatchPtrOutput) ToLifecycleHandlerPatchPtrOutputWithCont return o } +func (o LifecycleHandlerPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LifecycleHandlerPatch] { + return pulumix.Output[*LifecycleHandlerPatch]{ + OutputState: o.OutputState, + } +} + func (o LifecycleHandlerPatchPtrOutput) Elem() LifecycleHandlerPatchOutput { return o.ApplyT(func(v *LifecycleHandlerPatch) LifecycleHandlerPatch { if v != nil { @@ -25206,6 +28543,12 @@ func (i LifecyclePatchArgs) ToLifecyclePatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LifecyclePatchOutput) } +func (i LifecyclePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LifecyclePatch] { + return pulumix.Output[LifecyclePatch]{ + OutputState: i.ToLifecyclePatchOutputWithContext(ctx).OutputState, + } +} + func (i LifecyclePatchArgs) ToLifecyclePatchPtrOutput() LifecyclePatchPtrOutput { return i.ToLifecyclePatchPtrOutputWithContext(context.Background()) } @@ -25247,6 +28590,12 @@ func (i *lifecyclePatchPtrType) ToLifecyclePatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(LifecyclePatchPtrOutput) } +func (i *lifecyclePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LifecyclePatch] { + return pulumix.Output[*LifecyclePatch]{ + OutputState: i.ToLifecyclePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted. type LifecyclePatchOutput struct{ *pulumi.OutputState } @@ -25272,6 +28621,12 @@ func (o LifecyclePatchOutput) ToLifecyclePatchPtrOutputWithContext(ctx context.C }).(LifecyclePatchPtrOutput) } +func (o LifecyclePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LifecyclePatch] { + return pulumix.Output[LifecyclePatch]{ + OutputState: o.OutputState, + } +} + // PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks func (o LifecyclePatchOutput) PostStart() LifecycleHandlerPatchPtrOutput { return o.ApplyT(func(v LifecyclePatch) *LifecycleHandlerPatch { return v.PostStart }).(LifecycleHandlerPatchPtrOutput) @@ -25296,6 +28651,12 @@ func (o LifecyclePatchPtrOutput) ToLifecyclePatchPtrOutputWithContext(ctx contex return o } +func (o LifecyclePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LifecyclePatch] { + return pulumix.Output[*LifecyclePatch]{ + OutputState: o.OutputState, + } +} + func (o LifecyclePatchPtrOutput) Elem() LifecyclePatchOutput { return o.ApplyT(func(v *LifecyclePatch) LifecyclePatch { if v != nil { @@ -25373,6 +28734,12 @@ func (i LimitRangeTypeArgs) ToLimitRangeTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LimitRangeTypeOutput) } +func (i LimitRangeTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangeType] { + return pulumix.Output[LimitRangeType]{ + OutputState: i.ToLimitRangeTypeOutputWithContext(ctx).OutputState, + } +} + // LimitRangeTypeArrayInput is an input type that accepts LimitRangeTypeArray and LimitRangeTypeArrayOutput values. // You can construct a concrete instance of `LimitRangeTypeArrayInput` via: // @@ -25398,6 +28765,12 @@ func (i LimitRangeTypeArray) ToLimitRangeTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(LimitRangeTypeArrayOutput) } +func (i LimitRangeTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]LimitRangeType] { + return pulumix.Output[[]LimitRangeType]{ + OutputState: i.ToLimitRangeTypeArrayOutputWithContext(ctx).OutputState, + } +} + // LimitRange sets resource usage limits for each kind of resource in a Namespace. type LimitRangeTypeOutput struct{ *pulumi.OutputState } @@ -25413,6 +28786,12 @@ func (o LimitRangeTypeOutput) ToLimitRangeTypeOutputWithContext(ctx context.Cont return o } +func (o LimitRangeTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangeType] { + return pulumix.Output[LimitRangeType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LimitRangeTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LimitRangeType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -25447,6 +28826,12 @@ func (o LimitRangeTypeArrayOutput) ToLimitRangeTypeArrayOutputWithContext(ctx co return o } +func (o LimitRangeTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LimitRangeType] { + return pulumix.Output[[]LimitRangeType]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeTypeArrayOutput) Index(i pulumi.IntInput) LimitRangeTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LimitRangeType { return vs[0].([]LimitRangeType)[vs[1].(int)] @@ -25508,6 +28893,12 @@ func (i LimitRangeItemArgs) ToLimitRangeItemOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LimitRangeItemOutput) } +func (i LimitRangeItemArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangeItem] { + return pulumix.Output[LimitRangeItem]{ + OutputState: i.ToLimitRangeItemOutputWithContext(ctx).OutputState, + } +} + // LimitRangeItemArrayInput is an input type that accepts LimitRangeItemArray and LimitRangeItemArrayOutput values. // You can construct a concrete instance of `LimitRangeItemArrayInput` via: // @@ -25533,6 +28924,12 @@ func (i LimitRangeItemArray) ToLimitRangeItemArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(LimitRangeItemArrayOutput) } +func (i LimitRangeItemArray) ToOutput(ctx context.Context) pulumix.Output[[]LimitRangeItem] { + return pulumix.Output[[]LimitRangeItem]{ + OutputState: i.ToLimitRangeItemArrayOutputWithContext(ctx).OutputState, + } +} + // LimitRangeItem defines a min/max usage limit for any resource that matches on kind. type LimitRangeItemOutput struct{ *pulumi.OutputState } @@ -25548,6 +28945,12 @@ func (o LimitRangeItemOutput) ToLimitRangeItemOutputWithContext(ctx context.Cont return o } +func (o LimitRangeItemOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangeItem] { + return pulumix.Output[LimitRangeItem]{ + OutputState: o.OutputState, + } +} + // Default resource requirement limit value by resource name if resource limit is omitted. func (o LimitRangeItemOutput) Default() pulumi.StringMapOutput { return o.ApplyT(func(v LimitRangeItem) map[string]string { return v.Default }).(pulumi.StringMapOutput) @@ -25592,6 +28995,12 @@ func (o LimitRangeItemArrayOutput) ToLimitRangeItemArrayOutputWithContext(ctx co return o } +func (o LimitRangeItemArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LimitRangeItem] { + return pulumix.Output[[]LimitRangeItem]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeItemArrayOutput) Index(i pulumi.IntInput) LimitRangeItemOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LimitRangeItem { return vs[0].([]LimitRangeItem)[vs[1].(int)] @@ -25653,6 +29062,12 @@ func (i LimitRangeItemPatchArgs) ToLimitRangeItemPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(LimitRangeItemPatchOutput) } +func (i LimitRangeItemPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangeItemPatch] { + return pulumix.Output[LimitRangeItemPatch]{ + OutputState: i.ToLimitRangeItemPatchOutputWithContext(ctx).OutputState, + } +} + // LimitRangeItemPatchArrayInput is an input type that accepts LimitRangeItemPatchArray and LimitRangeItemPatchArrayOutput values. // You can construct a concrete instance of `LimitRangeItemPatchArrayInput` via: // @@ -25678,6 +29093,12 @@ func (i LimitRangeItemPatchArray) ToLimitRangeItemPatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(LimitRangeItemPatchArrayOutput) } +func (i LimitRangeItemPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]LimitRangeItemPatch] { + return pulumix.Output[[]LimitRangeItemPatch]{ + OutputState: i.ToLimitRangeItemPatchArrayOutputWithContext(ctx).OutputState, + } +} + // LimitRangeItem defines a min/max usage limit for any resource that matches on kind. type LimitRangeItemPatchOutput struct{ *pulumi.OutputState } @@ -25693,6 +29114,12 @@ func (o LimitRangeItemPatchOutput) ToLimitRangeItemPatchOutputWithContext(ctx co return o } +func (o LimitRangeItemPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangeItemPatch] { + return pulumix.Output[LimitRangeItemPatch]{ + OutputState: o.OutputState, + } +} + // Default resource requirement limit value by resource name if resource limit is omitted. func (o LimitRangeItemPatchOutput) Default() pulumi.StringMapOutput { return o.ApplyT(func(v LimitRangeItemPatch) map[string]string { return v.Default }).(pulumi.StringMapOutput) @@ -25737,6 +29164,12 @@ func (o LimitRangeItemPatchArrayOutput) ToLimitRangeItemPatchArrayOutputWithCont return o } +func (o LimitRangeItemPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LimitRangeItemPatch] { + return pulumix.Output[[]LimitRangeItemPatch]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeItemPatchArrayOutput) Index(i pulumi.IntInput) LimitRangeItemPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LimitRangeItemPatch { return vs[0].([]LimitRangeItemPatch)[vs[1].(int)] @@ -25790,6 +29223,12 @@ func (i LimitRangeListTypeArgs) ToLimitRangeListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LimitRangeListTypeOutput) } +func (i LimitRangeListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangeListType] { + return pulumix.Output[LimitRangeListType]{ + OutputState: i.ToLimitRangeListTypeOutputWithContext(ctx).OutputState, + } +} + // LimitRangeList is a list of LimitRange items. type LimitRangeListTypeOutput struct{ *pulumi.OutputState } @@ -25805,6 +29244,12 @@ func (o LimitRangeListTypeOutput) ToLimitRangeListTypeOutputWithContext(ctx cont return o } +func (o LimitRangeListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangeListType] { + return pulumix.Output[LimitRangeListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LimitRangeListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LimitRangeListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -25872,6 +29317,12 @@ func (i LimitRangePatchTypeArgs) ToLimitRangePatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(LimitRangePatchTypeOutput) } +func (i LimitRangePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangePatchType] { + return pulumix.Output[LimitRangePatchType]{ + OutputState: i.ToLimitRangePatchTypeOutputWithContext(ctx).OutputState, + } +} + // LimitRange sets resource usage limits for each kind of resource in a Namespace. type LimitRangePatchTypeOutput struct{ *pulumi.OutputState } @@ -25887,6 +29338,12 @@ func (o LimitRangePatchTypeOutput) ToLimitRangePatchTypeOutputWithContext(ctx co return o } +func (o LimitRangePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangePatchType] { + return pulumix.Output[LimitRangePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o LimitRangePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v LimitRangePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -25942,6 +29399,12 @@ func (i LimitRangeSpecArgs) ToLimitRangeSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(LimitRangeSpecOutput) } +func (i LimitRangeSpecArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangeSpec] { + return pulumix.Output[LimitRangeSpec]{ + OutputState: i.ToLimitRangeSpecOutputWithContext(ctx).OutputState, + } +} + func (i LimitRangeSpecArgs) ToLimitRangeSpecPtrOutput() LimitRangeSpecPtrOutput { return i.ToLimitRangeSpecPtrOutputWithContext(context.Background()) } @@ -25983,6 +29446,12 @@ func (i *limitRangeSpecPtrType) ToLimitRangeSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(LimitRangeSpecPtrOutput) } +func (i *limitRangeSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitRangeSpec] { + return pulumix.Output[*LimitRangeSpec]{ + OutputState: i.ToLimitRangeSpecPtrOutputWithContext(ctx).OutputState, + } +} + // LimitRangeSpec defines a min/max usage limit for resources that match on kind. type LimitRangeSpecOutput struct{ *pulumi.OutputState } @@ -26008,6 +29477,12 @@ func (o LimitRangeSpecOutput) ToLimitRangeSpecPtrOutputWithContext(ctx context.C }).(LimitRangeSpecPtrOutput) } +func (o LimitRangeSpecOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangeSpec] { + return pulumix.Output[LimitRangeSpec]{ + OutputState: o.OutputState, + } +} + // Limits is the list of LimitRangeItem objects that are enforced. func (o LimitRangeSpecOutput) Limits() LimitRangeItemArrayOutput { return o.ApplyT(func(v LimitRangeSpec) []LimitRangeItem { return v.Limits }).(LimitRangeItemArrayOutput) @@ -26027,6 +29502,12 @@ func (o LimitRangeSpecPtrOutput) ToLimitRangeSpecPtrOutputWithContext(ctx contex return o } +func (o LimitRangeSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitRangeSpec] { + return pulumix.Output[*LimitRangeSpec]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeSpecPtrOutput) Elem() LimitRangeSpecOutput { return o.ApplyT(func(v *LimitRangeSpec) LimitRangeSpec { if v != nil { @@ -26082,6 +29563,12 @@ func (i LimitRangeSpecPatchArgs) ToLimitRangeSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(LimitRangeSpecPatchOutput) } +func (i LimitRangeSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitRangeSpecPatch] { + return pulumix.Output[LimitRangeSpecPatch]{ + OutputState: i.ToLimitRangeSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitRangeSpecPatchArgs) ToLimitRangeSpecPatchPtrOutput() LimitRangeSpecPatchPtrOutput { return i.ToLimitRangeSpecPatchPtrOutputWithContext(context.Background()) } @@ -26123,6 +29610,12 @@ func (i *limitRangeSpecPatchPtrType) ToLimitRangeSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(LimitRangeSpecPatchPtrOutput) } +func (i *limitRangeSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitRangeSpecPatch] { + return pulumix.Output[*LimitRangeSpecPatch]{ + OutputState: i.ToLimitRangeSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitRangeSpec defines a min/max usage limit for resources that match on kind. type LimitRangeSpecPatchOutput struct{ *pulumi.OutputState } @@ -26148,6 +29641,12 @@ func (o LimitRangeSpecPatchOutput) ToLimitRangeSpecPatchPtrOutputWithContext(ctx }).(LimitRangeSpecPatchPtrOutput) } +func (o LimitRangeSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitRangeSpecPatch] { + return pulumix.Output[LimitRangeSpecPatch]{ + OutputState: o.OutputState, + } +} + // Limits is the list of LimitRangeItem objects that are enforced. func (o LimitRangeSpecPatchOutput) Limits() LimitRangeItemPatchArrayOutput { return o.ApplyT(func(v LimitRangeSpecPatch) []LimitRangeItemPatch { return v.Limits }).(LimitRangeItemPatchArrayOutput) @@ -26167,6 +29666,12 @@ func (o LimitRangeSpecPatchPtrOutput) ToLimitRangeSpecPatchPtrOutputWithContext( return o } +func (o LimitRangeSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitRangeSpecPatch] { + return pulumix.Output[*LimitRangeSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o LimitRangeSpecPatchPtrOutput) Elem() LimitRangeSpecPatchOutput { return o.ApplyT(func(v *LimitRangeSpecPatch) LimitRangeSpecPatch { if v != nil { @@ -26230,6 +29735,12 @@ func (i LoadBalancerIngressArgs) ToLoadBalancerIngressOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerIngressOutput) } +func (i LoadBalancerIngressArgs) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerIngress] { + return pulumix.Output[LoadBalancerIngress]{ + OutputState: i.ToLoadBalancerIngressOutputWithContext(ctx).OutputState, + } +} + // LoadBalancerIngressArrayInput is an input type that accepts LoadBalancerIngressArray and LoadBalancerIngressArrayOutput values. // You can construct a concrete instance of `LoadBalancerIngressArrayInput` via: // @@ -26255,6 +29766,12 @@ func (i LoadBalancerIngressArray) ToLoadBalancerIngressArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerIngressArrayOutput) } +func (i LoadBalancerIngressArray) ToOutput(ctx context.Context) pulumix.Output[[]LoadBalancerIngress] { + return pulumix.Output[[]LoadBalancerIngress]{ + OutputState: i.ToLoadBalancerIngressArrayOutputWithContext(ctx).OutputState, + } +} + // LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point. type LoadBalancerIngressOutput struct{ *pulumi.OutputState } @@ -26270,6 +29787,12 @@ func (o LoadBalancerIngressOutput) ToLoadBalancerIngressOutputWithContext(ctx co return o } +func (o LoadBalancerIngressOutput) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerIngress] { + return pulumix.Output[LoadBalancerIngress]{ + OutputState: o.OutputState, + } +} + // Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers) func (o LoadBalancerIngressOutput) Hostname() pulumi.StringPtrOutput { return o.ApplyT(func(v LoadBalancerIngress) *string { return v.Hostname }).(pulumi.StringPtrOutput) @@ -26299,6 +29822,12 @@ func (o LoadBalancerIngressArrayOutput) ToLoadBalancerIngressArrayOutputWithCont return o } +func (o LoadBalancerIngressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LoadBalancerIngress] { + return pulumix.Output[[]LoadBalancerIngress]{ + OutputState: o.OutputState, + } +} + func (o LoadBalancerIngressArrayOutput) Index(i pulumi.IntInput) LoadBalancerIngressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerIngress { return vs[0].([]LoadBalancerIngress)[vs[1].(int)] @@ -26348,6 +29877,12 @@ func (i LoadBalancerIngressPatchArgs) ToLoadBalancerIngressPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerIngressPatchOutput) } +func (i LoadBalancerIngressPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerIngressPatch] { + return pulumix.Output[LoadBalancerIngressPatch]{ + OutputState: i.ToLoadBalancerIngressPatchOutputWithContext(ctx).OutputState, + } +} + // LoadBalancerIngressPatchArrayInput is an input type that accepts LoadBalancerIngressPatchArray and LoadBalancerIngressPatchArrayOutput values. // You can construct a concrete instance of `LoadBalancerIngressPatchArrayInput` via: // @@ -26373,6 +29908,12 @@ func (i LoadBalancerIngressPatchArray) ToLoadBalancerIngressPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerIngressPatchArrayOutput) } +func (i LoadBalancerIngressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]LoadBalancerIngressPatch] { + return pulumix.Output[[]LoadBalancerIngressPatch]{ + OutputState: i.ToLoadBalancerIngressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point. type LoadBalancerIngressPatchOutput struct{ *pulumi.OutputState } @@ -26388,6 +29929,12 @@ func (o LoadBalancerIngressPatchOutput) ToLoadBalancerIngressPatchOutputWithCont return o } +func (o LoadBalancerIngressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerIngressPatch] { + return pulumix.Output[LoadBalancerIngressPatch]{ + OutputState: o.OutputState, + } +} + // Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers) func (o LoadBalancerIngressPatchOutput) Hostname() pulumi.StringPtrOutput { return o.ApplyT(func(v LoadBalancerIngressPatch) *string { return v.Hostname }).(pulumi.StringPtrOutput) @@ -26417,6 +29964,12 @@ func (o LoadBalancerIngressPatchArrayOutput) ToLoadBalancerIngressPatchArrayOutp return o } +func (o LoadBalancerIngressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LoadBalancerIngressPatch] { + return pulumix.Output[[]LoadBalancerIngressPatch]{ + OutputState: o.OutputState, + } +} + func (o LoadBalancerIngressPatchArrayOutput) Index(i pulumi.IntInput) LoadBalancerIngressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerIngressPatch { return vs[0].([]LoadBalancerIngressPatch)[vs[1].(int)] @@ -26458,6 +30011,12 @@ func (i LoadBalancerStatusArgs) ToLoadBalancerStatusOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerStatusOutput) } +func (i LoadBalancerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerStatus] { + return pulumix.Output[LoadBalancerStatus]{ + OutputState: i.ToLoadBalancerStatusOutputWithContext(ctx).OutputState, + } +} + func (i LoadBalancerStatusArgs) ToLoadBalancerStatusPtrOutput() LoadBalancerStatusPtrOutput { return i.ToLoadBalancerStatusPtrOutputWithContext(context.Background()) } @@ -26499,6 +30058,12 @@ func (i *loadBalancerStatusPtrType) ToLoadBalancerStatusPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerStatusPtrOutput) } +func (i *loadBalancerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*LoadBalancerStatus] { + return pulumix.Output[*LoadBalancerStatus]{ + OutputState: i.ToLoadBalancerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // LoadBalancerStatus represents the status of a load-balancer. type LoadBalancerStatusOutput struct{ *pulumi.OutputState } @@ -26524,6 +30089,12 @@ func (o LoadBalancerStatusOutput) ToLoadBalancerStatusPtrOutputWithContext(ctx c }).(LoadBalancerStatusPtrOutput) } +func (o LoadBalancerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerStatus] { + return pulumix.Output[LoadBalancerStatus]{ + OutputState: o.OutputState, + } +} + // Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points. func (o LoadBalancerStatusOutput) Ingress() LoadBalancerIngressArrayOutput { return o.ApplyT(func(v LoadBalancerStatus) []LoadBalancerIngress { return v.Ingress }).(LoadBalancerIngressArrayOutput) @@ -26543,6 +30114,12 @@ func (o LoadBalancerStatusPtrOutput) ToLoadBalancerStatusPtrOutputWithContext(ct return o } +func (o LoadBalancerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LoadBalancerStatus] { + return pulumix.Output[*LoadBalancerStatus]{ + OutputState: o.OutputState, + } +} + func (o LoadBalancerStatusPtrOutput) Elem() LoadBalancerStatusOutput { return o.ApplyT(func(v *LoadBalancerStatus) LoadBalancerStatus { if v != nil { @@ -26598,6 +30175,12 @@ func (i LoadBalancerStatusPatchArgs) ToLoadBalancerStatusPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerStatusPatchOutput) } +func (i LoadBalancerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerStatusPatch] { + return pulumix.Output[LoadBalancerStatusPatch]{ + OutputState: i.ToLoadBalancerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i LoadBalancerStatusPatchArgs) ToLoadBalancerStatusPatchPtrOutput() LoadBalancerStatusPatchPtrOutput { return i.ToLoadBalancerStatusPatchPtrOutputWithContext(context.Background()) } @@ -26639,6 +30222,12 @@ func (i *loadBalancerStatusPatchPtrType) ToLoadBalancerStatusPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerStatusPatchPtrOutput) } +func (i *loadBalancerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LoadBalancerStatusPatch] { + return pulumix.Output[*LoadBalancerStatusPatch]{ + OutputState: i.ToLoadBalancerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LoadBalancerStatus represents the status of a load-balancer. type LoadBalancerStatusPatchOutput struct{ *pulumi.OutputState } @@ -26664,6 +30253,12 @@ func (o LoadBalancerStatusPatchOutput) ToLoadBalancerStatusPatchPtrOutputWithCon }).(LoadBalancerStatusPatchPtrOutput) } +func (o LoadBalancerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LoadBalancerStatusPatch] { + return pulumix.Output[LoadBalancerStatusPatch]{ + OutputState: o.OutputState, + } +} + // Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points. func (o LoadBalancerStatusPatchOutput) Ingress() LoadBalancerIngressPatchArrayOutput { return o.ApplyT(func(v LoadBalancerStatusPatch) []LoadBalancerIngressPatch { return v.Ingress }).(LoadBalancerIngressPatchArrayOutput) @@ -26683,6 +30278,12 @@ func (o LoadBalancerStatusPatchPtrOutput) ToLoadBalancerStatusPatchPtrOutputWith return o } +func (o LoadBalancerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LoadBalancerStatusPatch] { + return pulumix.Output[*LoadBalancerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o LoadBalancerStatusPatchPtrOutput) Elem() LoadBalancerStatusPatchOutput { return o.ApplyT(func(v *LoadBalancerStatusPatch) LoadBalancerStatusPatch { if v != nil { @@ -26738,6 +30339,12 @@ func (i LocalObjectReferenceArgs) ToLocalObjectReferenceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(LocalObjectReferenceOutput) } +func (i LocalObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[LocalObjectReference] { + return pulumix.Output[LocalObjectReference]{ + OutputState: i.ToLocalObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i LocalObjectReferenceArgs) ToLocalObjectReferencePtrOutput() LocalObjectReferencePtrOutput { return i.ToLocalObjectReferencePtrOutputWithContext(context.Background()) } @@ -26779,6 +30386,12 @@ func (i *localObjectReferencePtrType) ToLocalObjectReferencePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(LocalObjectReferencePtrOutput) } +func (i *localObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*LocalObjectReference] { + return pulumix.Output[*LocalObjectReference]{ + OutputState: i.ToLocalObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // LocalObjectReferenceArrayInput is an input type that accepts LocalObjectReferenceArray and LocalObjectReferenceArrayOutput values. // You can construct a concrete instance of `LocalObjectReferenceArrayInput` via: // @@ -26804,6 +30417,12 @@ func (i LocalObjectReferenceArray) ToLocalObjectReferenceArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(LocalObjectReferenceArrayOutput) } +func (i LocalObjectReferenceArray) ToOutput(ctx context.Context) pulumix.Output[[]LocalObjectReference] { + return pulumix.Output[[]LocalObjectReference]{ + OutputState: i.ToLocalObjectReferenceArrayOutputWithContext(ctx).OutputState, + } +} + // LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. type LocalObjectReferenceOutput struct{ *pulumi.OutputState } @@ -26829,6 +30448,12 @@ func (o LocalObjectReferenceOutput) ToLocalObjectReferencePtrOutputWithContext(c }).(LocalObjectReferencePtrOutput) } +func (o LocalObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[LocalObjectReference] { + return pulumix.Output[LocalObjectReference]{ + OutputState: o.OutputState, + } +} + // Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names func (o LocalObjectReferenceOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalObjectReference) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -26848,6 +30473,12 @@ func (o LocalObjectReferencePtrOutput) ToLocalObjectReferencePtrOutputWithContex return o } +func (o LocalObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LocalObjectReference] { + return pulumix.Output[*LocalObjectReference]{ + OutputState: o.OutputState, + } +} + func (o LocalObjectReferencePtrOutput) Elem() LocalObjectReferenceOutput { return o.ApplyT(func(v *LocalObjectReference) LocalObjectReference { if v != nil { @@ -26882,6 +30513,12 @@ func (o LocalObjectReferenceArrayOutput) ToLocalObjectReferenceArrayOutputWithCo return o } +func (o LocalObjectReferenceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LocalObjectReference] { + return pulumix.Output[[]LocalObjectReference]{ + OutputState: o.OutputState, + } +} + func (o LocalObjectReferenceArrayOutput) Index(i pulumi.IntInput) LocalObjectReferenceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LocalObjectReference { return vs[0].([]LocalObjectReference)[vs[1].(int)] @@ -26923,6 +30560,12 @@ func (i LocalObjectReferencePatchArgs) ToLocalObjectReferencePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(LocalObjectReferencePatchOutput) } +func (i LocalObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LocalObjectReferencePatch] { + return pulumix.Output[LocalObjectReferencePatch]{ + OutputState: i.ToLocalObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i LocalObjectReferencePatchArgs) ToLocalObjectReferencePatchPtrOutput() LocalObjectReferencePatchPtrOutput { return i.ToLocalObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -26964,6 +30607,12 @@ func (i *localObjectReferencePatchPtrType) ToLocalObjectReferencePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(LocalObjectReferencePatchPtrOutput) } +func (i *localObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LocalObjectReferencePatch] { + return pulumix.Output[*LocalObjectReferencePatch]{ + OutputState: i.ToLocalObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // LocalObjectReferencePatchArrayInput is an input type that accepts LocalObjectReferencePatchArray and LocalObjectReferencePatchArrayOutput values. // You can construct a concrete instance of `LocalObjectReferencePatchArrayInput` via: // @@ -26989,6 +30638,12 @@ func (i LocalObjectReferencePatchArray) ToLocalObjectReferencePatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(LocalObjectReferencePatchArrayOutput) } +func (i LocalObjectReferencePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]LocalObjectReferencePatch] { + return pulumix.Output[[]LocalObjectReferencePatch]{ + OutputState: i.ToLocalObjectReferencePatchArrayOutputWithContext(ctx).OutputState, + } +} + // LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. type LocalObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -27014,6 +30669,12 @@ func (o LocalObjectReferencePatchOutput) ToLocalObjectReferencePatchPtrOutputWit }).(LocalObjectReferencePatchPtrOutput) } +func (o LocalObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LocalObjectReferencePatch] { + return pulumix.Output[LocalObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names func (o LocalObjectReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalObjectReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -27033,6 +30694,12 @@ func (o LocalObjectReferencePatchPtrOutput) ToLocalObjectReferencePatchPtrOutput return o } +func (o LocalObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LocalObjectReferencePatch] { + return pulumix.Output[*LocalObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o LocalObjectReferencePatchPtrOutput) Elem() LocalObjectReferencePatchOutput { return o.ApplyT(func(v *LocalObjectReferencePatch) LocalObjectReferencePatch { if v != nil { @@ -27067,6 +30734,12 @@ func (o LocalObjectReferencePatchArrayOutput) ToLocalObjectReferencePatchArrayOu return o } +func (o LocalObjectReferencePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LocalObjectReferencePatch] { + return pulumix.Output[[]LocalObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o LocalObjectReferencePatchArrayOutput) Index(i pulumi.IntInput) LocalObjectReferencePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LocalObjectReferencePatch { return vs[0].([]LocalObjectReferencePatch)[vs[1].(int)] @@ -27112,6 +30785,12 @@ func (i LocalVolumeSourceArgs) ToLocalVolumeSourceOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(LocalVolumeSourceOutput) } +func (i LocalVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[LocalVolumeSource] { + return pulumix.Output[LocalVolumeSource]{ + OutputState: i.ToLocalVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i LocalVolumeSourceArgs) ToLocalVolumeSourcePtrOutput() LocalVolumeSourcePtrOutput { return i.ToLocalVolumeSourcePtrOutputWithContext(context.Background()) } @@ -27153,6 +30832,12 @@ func (i *localVolumeSourcePtrType) ToLocalVolumeSourcePtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(LocalVolumeSourcePtrOutput) } +func (i *localVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*LocalVolumeSource] { + return pulumix.Output[*LocalVolumeSource]{ + OutputState: i.ToLocalVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Local represents directly-attached storage with node affinity (Beta feature) type LocalVolumeSourceOutput struct{ *pulumi.OutputState } @@ -27178,6 +30863,12 @@ func (o LocalVolumeSourceOutput) ToLocalVolumeSourcePtrOutputWithContext(ctx con }).(LocalVolumeSourcePtrOutput) } +func (o LocalVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[LocalVolumeSource] { + return pulumix.Output[LocalVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". The default value is to auto-select a filesystem if unspecified. func (o LocalVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -27202,6 +30893,12 @@ func (o LocalVolumeSourcePtrOutput) ToLocalVolumeSourcePtrOutputWithContext(ctx return o } +func (o LocalVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LocalVolumeSource] { + return pulumix.Output[*LocalVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o LocalVolumeSourcePtrOutput) Elem() LocalVolumeSourceOutput { return o.ApplyT(func(v *LocalVolumeSource) LocalVolumeSource { if v != nil { @@ -27271,6 +30968,12 @@ func (i LocalVolumeSourcePatchArgs) ToLocalVolumeSourcePatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(LocalVolumeSourcePatchOutput) } +func (i LocalVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LocalVolumeSourcePatch] { + return pulumix.Output[LocalVolumeSourcePatch]{ + OutputState: i.ToLocalVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i LocalVolumeSourcePatchArgs) ToLocalVolumeSourcePatchPtrOutput() LocalVolumeSourcePatchPtrOutput { return i.ToLocalVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -27312,6 +31015,12 @@ func (i *localVolumeSourcePatchPtrType) ToLocalVolumeSourcePatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(LocalVolumeSourcePatchPtrOutput) } +func (i *localVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LocalVolumeSourcePatch] { + return pulumix.Output[*LocalVolumeSourcePatch]{ + OutputState: i.ToLocalVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Local represents directly-attached storage with node affinity (Beta feature) type LocalVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -27337,6 +31046,12 @@ func (o LocalVolumeSourcePatchOutput) ToLocalVolumeSourcePatchPtrOutputWithConte }).(LocalVolumeSourcePatchPtrOutput) } +func (o LocalVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LocalVolumeSourcePatch] { + return pulumix.Output[LocalVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". The default value is to auto-select a filesystem if unspecified. func (o LocalVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v LocalVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -27361,6 +31076,12 @@ func (o LocalVolumeSourcePatchPtrOutput) ToLocalVolumeSourcePatchPtrOutputWithCo return o } +func (o LocalVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LocalVolumeSourcePatch] { + return pulumix.Output[*LocalVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o LocalVolumeSourcePatchPtrOutput) Elem() LocalVolumeSourcePatchOutput { return o.ApplyT(func(v *LocalVolumeSourcePatch) LocalVolumeSourcePatch { if v != nil { @@ -27434,6 +31155,12 @@ func (i NFSVolumeSourceArgs) ToNFSVolumeSourceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(NFSVolumeSourceOutput) } +func (i NFSVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[NFSVolumeSource] { + return pulumix.Output[NFSVolumeSource]{ + OutputState: i.ToNFSVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i NFSVolumeSourceArgs) ToNFSVolumeSourcePtrOutput() NFSVolumeSourcePtrOutput { return i.ToNFSVolumeSourcePtrOutputWithContext(context.Background()) } @@ -27475,6 +31202,12 @@ func (i *nfsvolumeSourcePtrType) ToNFSVolumeSourcePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(NFSVolumeSourcePtrOutput) } +func (i *nfsvolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*NFSVolumeSource] { + return pulumix.Output[*NFSVolumeSource]{ + OutputState: i.ToNFSVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling. type NFSVolumeSourceOutput struct{ *pulumi.OutputState } @@ -27500,6 +31233,12 @@ func (o NFSVolumeSourceOutput) ToNFSVolumeSourcePtrOutputWithContext(ctx context }).(NFSVolumeSourcePtrOutput) } +func (o NFSVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[NFSVolumeSource] { + return pulumix.Output[NFSVolumeSource]{ + OutputState: o.OutputState, + } +} + // path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs func (o NFSVolumeSourceOutput) Path() pulumi.StringOutput { return o.ApplyT(func(v NFSVolumeSource) string { return v.Path }).(pulumi.StringOutput) @@ -27529,6 +31268,12 @@ func (o NFSVolumeSourcePtrOutput) ToNFSVolumeSourcePtrOutputWithContext(ctx cont return o } +func (o NFSVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NFSVolumeSource] { + return pulumix.Output[*NFSVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o NFSVolumeSourcePtrOutput) Elem() NFSVolumeSourceOutput { return o.ApplyT(func(v *NFSVolumeSource) NFSVolumeSource { if v != nil { @@ -27612,6 +31357,12 @@ func (i NFSVolumeSourcePatchArgs) ToNFSVolumeSourcePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NFSVolumeSourcePatchOutput) } +func (i NFSVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NFSVolumeSourcePatch] { + return pulumix.Output[NFSVolumeSourcePatch]{ + OutputState: i.ToNFSVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i NFSVolumeSourcePatchArgs) ToNFSVolumeSourcePatchPtrOutput() NFSVolumeSourcePatchPtrOutput { return i.ToNFSVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -27653,6 +31404,12 @@ func (i *nfsvolumeSourcePatchPtrType) ToNFSVolumeSourcePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(NFSVolumeSourcePatchPtrOutput) } +func (i *nfsvolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NFSVolumeSourcePatch] { + return pulumix.Output[*NFSVolumeSourcePatch]{ + OutputState: i.ToNFSVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling. type NFSVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -27678,6 +31435,12 @@ func (o NFSVolumeSourcePatchOutput) ToNFSVolumeSourcePatchPtrOutputWithContext(c }).(NFSVolumeSourcePatchPtrOutput) } +func (o NFSVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NFSVolumeSourcePatch] { + return pulumix.Output[NFSVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs func (o NFSVolumeSourcePatchOutput) Path() pulumi.StringPtrOutput { return o.ApplyT(func(v NFSVolumeSourcePatch) *string { return v.Path }).(pulumi.StringPtrOutput) @@ -27707,6 +31470,12 @@ func (o NFSVolumeSourcePatchPtrOutput) ToNFSVolumeSourcePatchPtrOutputWithContex return o } +func (o NFSVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NFSVolumeSourcePatch] { + return pulumix.Output[*NFSVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o NFSVolumeSourcePatchPtrOutput) Elem() NFSVolumeSourcePatchOutput { return o.ApplyT(func(v *NFSVolumeSourcePatch) NFSVolumeSourcePatch { if v != nil { @@ -27798,6 +31567,12 @@ func (i NamespaceTypeArgs) ToNamespaceTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(NamespaceTypeOutput) } +func (i NamespaceTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceType] { + return pulumix.Output[NamespaceType]{ + OutputState: i.ToNamespaceTypeOutputWithContext(ctx).OutputState, + } +} + // NamespaceTypeArrayInput is an input type that accepts NamespaceTypeArray and NamespaceTypeArrayOutput values. // You can construct a concrete instance of `NamespaceTypeArrayInput` via: // @@ -27823,6 +31598,12 @@ func (i NamespaceTypeArray) ToNamespaceTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NamespaceTypeArrayOutput) } +func (i NamespaceTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]NamespaceType] { + return pulumix.Output[[]NamespaceType]{ + OutputState: i.ToNamespaceTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Namespace provides a scope for Names. Use of multiple namespaces is optional. type NamespaceTypeOutput struct{ *pulumi.OutputState } @@ -27838,6 +31619,12 @@ func (o NamespaceTypeOutput) ToNamespaceTypeOutputWithContext(ctx context.Contex return o } +func (o NamespaceTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceType] { + return pulumix.Output[NamespaceType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NamespaceTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NamespaceType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -27877,6 +31664,12 @@ func (o NamespaceTypeArrayOutput) ToNamespaceTypeArrayOutputWithContext(ctx cont return o } +func (o NamespaceTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamespaceType] { + return pulumix.Output[[]NamespaceType]{ + OutputState: o.OutputState, + } +} + func (o NamespaceTypeArrayOutput) Index(i pulumi.IntInput) NamespaceTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamespaceType { return vs[0].([]NamespaceType)[vs[1].(int)] @@ -27928,6 +31721,12 @@ func (i NamespaceConditionArgs) ToNamespaceConditionOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NamespaceConditionOutput) } +func (i NamespaceConditionArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceCondition] { + return pulumix.Output[NamespaceCondition]{ + OutputState: i.ToNamespaceConditionOutputWithContext(ctx).OutputState, + } +} + // NamespaceConditionArrayInput is an input type that accepts NamespaceConditionArray and NamespaceConditionArrayOutput values. // You can construct a concrete instance of `NamespaceConditionArrayInput` via: // @@ -27953,6 +31752,12 @@ func (i NamespaceConditionArray) ToNamespaceConditionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NamespaceConditionArrayOutput) } +func (i NamespaceConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]NamespaceCondition] { + return pulumix.Output[[]NamespaceCondition]{ + OutputState: i.ToNamespaceConditionArrayOutputWithContext(ctx).OutputState, + } +} + // NamespaceCondition contains details about state of namespace. type NamespaceConditionOutput struct{ *pulumi.OutputState } @@ -27968,6 +31773,12 @@ func (o NamespaceConditionOutput) ToNamespaceConditionOutputWithContext(ctx cont return o } +func (o NamespaceConditionOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceCondition] { + return pulumix.Output[NamespaceCondition]{ + OutputState: o.OutputState, + } +} + func (o NamespaceConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v NamespaceCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) } @@ -28004,6 +31815,12 @@ func (o NamespaceConditionArrayOutput) ToNamespaceConditionArrayOutputWithContex return o } +func (o NamespaceConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamespaceCondition] { + return pulumix.Output[[]NamespaceCondition]{ + OutputState: o.OutputState, + } +} + func (o NamespaceConditionArrayOutput) Index(i pulumi.IntInput) NamespaceConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamespaceCondition { return vs[0].([]NamespaceCondition)[vs[1].(int)] @@ -28055,6 +31872,12 @@ func (i NamespaceConditionPatchArgs) ToNamespaceConditionPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NamespaceConditionPatchOutput) } +func (i NamespaceConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceConditionPatch] { + return pulumix.Output[NamespaceConditionPatch]{ + OutputState: i.ToNamespaceConditionPatchOutputWithContext(ctx).OutputState, + } +} + // NamespaceConditionPatchArrayInput is an input type that accepts NamespaceConditionPatchArray and NamespaceConditionPatchArrayOutput values. // You can construct a concrete instance of `NamespaceConditionPatchArrayInput` via: // @@ -28080,6 +31903,12 @@ func (i NamespaceConditionPatchArray) ToNamespaceConditionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NamespaceConditionPatchArrayOutput) } +func (i NamespaceConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NamespaceConditionPatch] { + return pulumix.Output[[]NamespaceConditionPatch]{ + OutputState: i.ToNamespaceConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NamespaceCondition contains details about state of namespace. type NamespaceConditionPatchOutput struct{ *pulumi.OutputState } @@ -28095,6 +31924,12 @@ func (o NamespaceConditionPatchOutput) ToNamespaceConditionPatchOutputWithContex return o } +func (o NamespaceConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceConditionPatch] { + return pulumix.Output[NamespaceConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o NamespaceConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v NamespaceConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) } @@ -28131,6 +31966,12 @@ func (o NamespaceConditionPatchArrayOutput) ToNamespaceConditionPatchArrayOutput return o } +func (o NamespaceConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NamespaceConditionPatch] { + return pulumix.Output[[]NamespaceConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o NamespaceConditionPatchArrayOutput) Index(i pulumi.IntInput) NamespaceConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NamespaceConditionPatch { return vs[0].([]NamespaceConditionPatch)[vs[1].(int)] @@ -28184,6 +32025,12 @@ func (i NamespaceListTypeArgs) ToNamespaceListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NamespaceListTypeOutput) } +func (i NamespaceListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceListType] { + return pulumix.Output[NamespaceListType]{ + OutputState: i.ToNamespaceListTypeOutputWithContext(ctx).OutputState, + } +} + // NamespaceList is a list of Namespaces. type NamespaceListTypeOutput struct{ *pulumi.OutputState } @@ -28199,6 +32046,12 @@ func (o NamespaceListTypeOutput) ToNamespaceListTypeOutputWithContext(ctx contex return o } +func (o NamespaceListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceListType] { + return pulumix.Output[NamespaceListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NamespaceListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NamespaceListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -28270,6 +32123,12 @@ func (i NamespacePatchTypeArgs) ToNamespacePatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NamespacePatchTypeOutput) } +func (i NamespacePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NamespacePatchType] { + return pulumix.Output[NamespacePatchType]{ + OutputState: i.ToNamespacePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Namespace provides a scope for Names. Use of multiple namespaces is optional. type NamespacePatchTypeOutput struct{ *pulumi.OutputState } @@ -28285,6 +32144,12 @@ func (o NamespacePatchTypeOutput) ToNamespacePatchTypeOutputWithContext(ctx cont return o } +func (o NamespacePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NamespacePatchType] { + return pulumix.Output[NamespacePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NamespacePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NamespacePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -28345,6 +32210,12 @@ func (i NamespaceSpecArgs) ToNamespaceSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(NamespaceSpecOutput) } +func (i NamespaceSpecArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceSpec] { + return pulumix.Output[NamespaceSpec]{ + OutputState: i.ToNamespaceSpecOutputWithContext(ctx).OutputState, + } +} + func (i NamespaceSpecArgs) ToNamespaceSpecPtrOutput() NamespaceSpecPtrOutput { return i.ToNamespaceSpecPtrOutputWithContext(context.Background()) } @@ -28386,6 +32257,12 @@ func (i *namespaceSpecPtrType) ToNamespaceSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(NamespaceSpecPtrOutput) } +func (i *namespaceSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*NamespaceSpec] { + return pulumix.Output[*NamespaceSpec]{ + OutputState: i.ToNamespaceSpecPtrOutputWithContext(ctx).OutputState, + } +} + // NamespaceSpec describes the attributes on a Namespace. type NamespaceSpecOutput struct{ *pulumi.OutputState } @@ -28411,6 +32288,12 @@ func (o NamespaceSpecOutput) ToNamespaceSpecPtrOutputWithContext(ctx context.Con }).(NamespaceSpecPtrOutput) } +func (o NamespaceSpecOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceSpec] { + return pulumix.Output[NamespaceSpec]{ + OutputState: o.OutputState, + } +} + // Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/ func (o NamespaceSpecOutput) Finalizers() pulumi.StringArrayOutput { return o.ApplyT(func(v NamespaceSpec) []string { return v.Finalizers }).(pulumi.StringArrayOutput) @@ -28430,6 +32313,12 @@ func (o NamespaceSpecPtrOutput) ToNamespaceSpecPtrOutputWithContext(ctx context. return o } +func (o NamespaceSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NamespaceSpec] { + return pulumix.Output[*NamespaceSpec]{ + OutputState: o.OutputState, + } +} + func (o NamespaceSpecPtrOutput) Elem() NamespaceSpecOutput { return o.ApplyT(func(v *NamespaceSpec) NamespaceSpec { if v != nil { @@ -28485,6 +32374,12 @@ func (i NamespaceSpecPatchArgs) ToNamespaceSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NamespaceSpecPatchOutput) } +func (i NamespaceSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceSpecPatch] { + return pulumix.Output[NamespaceSpecPatch]{ + OutputState: i.ToNamespaceSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i NamespaceSpecPatchArgs) ToNamespaceSpecPatchPtrOutput() NamespaceSpecPatchPtrOutput { return i.ToNamespaceSpecPatchPtrOutputWithContext(context.Background()) } @@ -28526,6 +32421,12 @@ func (i *namespaceSpecPatchPtrType) ToNamespaceSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NamespaceSpecPatchPtrOutput) } +func (i *namespaceSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NamespaceSpecPatch] { + return pulumix.Output[*NamespaceSpecPatch]{ + OutputState: i.ToNamespaceSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NamespaceSpec describes the attributes on a Namespace. type NamespaceSpecPatchOutput struct{ *pulumi.OutputState } @@ -28551,6 +32452,12 @@ func (o NamespaceSpecPatchOutput) ToNamespaceSpecPatchPtrOutputWithContext(ctx c }).(NamespaceSpecPatchPtrOutput) } +func (o NamespaceSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceSpecPatch] { + return pulumix.Output[NamespaceSpecPatch]{ + OutputState: o.OutputState, + } +} + // Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/ func (o NamespaceSpecPatchOutput) Finalizers() pulumi.StringArrayOutput { return o.ApplyT(func(v NamespaceSpecPatch) []string { return v.Finalizers }).(pulumi.StringArrayOutput) @@ -28570,6 +32477,12 @@ func (o NamespaceSpecPatchPtrOutput) ToNamespaceSpecPatchPtrOutputWithContext(ct return o } +func (o NamespaceSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NamespaceSpecPatch] { + return pulumix.Output[*NamespaceSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o NamespaceSpecPatchPtrOutput) Elem() NamespaceSpecPatchOutput { return o.ApplyT(func(v *NamespaceSpecPatch) NamespaceSpecPatch { if v != nil { @@ -28629,6 +32542,12 @@ func (i NamespaceStatusArgs) ToNamespaceStatusOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(NamespaceStatusOutput) } +func (i NamespaceStatusArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceStatus] { + return pulumix.Output[NamespaceStatus]{ + OutputState: i.ToNamespaceStatusOutputWithContext(ctx).OutputState, + } +} + func (i NamespaceStatusArgs) ToNamespaceStatusPtrOutput() NamespaceStatusPtrOutput { return i.ToNamespaceStatusPtrOutputWithContext(context.Background()) } @@ -28670,6 +32589,12 @@ func (i *namespaceStatusPtrType) ToNamespaceStatusPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(NamespaceStatusPtrOutput) } +func (i *namespaceStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*NamespaceStatus] { + return pulumix.Output[*NamespaceStatus]{ + OutputState: i.ToNamespaceStatusPtrOutputWithContext(ctx).OutputState, + } +} + // NamespaceStatus is information about the current status of a Namespace. type NamespaceStatusOutput struct{ *pulumi.OutputState } @@ -28695,6 +32620,12 @@ func (o NamespaceStatusOutput) ToNamespaceStatusPtrOutputWithContext(ctx context }).(NamespaceStatusPtrOutput) } +func (o NamespaceStatusOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceStatus] { + return pulumix.Output[NamespaceStatus]{ + OutputState: o.OutputState, + } +} + // Represents the latest available observations of a namespace's current state. func (o NamespaceStatusOutput) Conditions() NamespaceConditionArrayOutput { return o.ApplyT(func(v NamespaceStatus) []NamespaceCondition { return v.Conditions }).(NamespaceConditionArrayOutput) @@ -28719,6 +32650,12 @@ func (o NamespaceStatusPtrOutput) ToNamespaceStatusPtrOutputWithContext(ctx cont return o } +func (o NamespaceStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NamespaceStatus] { + return pulumix.Output[*NamespaceStatus]{ + OutputState: o.OutputState, + } +} + func (o NamespaceStatusPtrOutput) Elem() NamespaceStatusOutput { return o.ApplyT(func(v *NamespaceStatus) NamespaceStatus { if v != nil { @@ -28788,6 +32725,12 @@ func (i NamespaceStatusPatchArgs) ToNamespaceStatusPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NamespaceStatusPatchOutput) } +func (i NamespaceStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NamespaceStatusPatch] { + return pulumix.Output[NamespaceStatusPatch]{ + OutputState: i.ToNamespaceStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i NamespaceStatusPatchArgs) ToNamespaceStatusPatchPtrOutput() NamespaceStatusPatchPtrOutput { return i.ToNamespaceStatusPatchPtrOutputWithContext(context.Background()) } @@ -28829,6 +32772,12 @@ func (i *namespaceStatusPatchPtrType) ToNamespaceStatusPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(NamespaceStatusPatchPtrOutput) } +func (i *namespaceStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NamespaceStatusPatch] { + return pulumix.Output[*NamespaceStatusPatch]{ + OutputState: i.ToNamespaceStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NamespaceStatus is information about the current status of a Namespace. type NamespaceStatusPatchOutput struct{ *pulumi.OutputState } @@ -28854,6 +32803,12 @@ func (o NamespaceStatusPatchOutput) ToNamespaceStatusPatchPtrOutputWithContext(c }).(NamespaceStatusPatchPtrOutput) } +func (o NamespaceStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NamespaceStatusPatch] { + return pulumix.Output[NamespaceStatusPatch]{ + OutputState: o.OutputState, + } +} + // Represents the latest available observations of a namespace's current state. func (o NamespaceStatusPatchOutput) Conditions() NamespaceConditionPatchArrayOutput { return o.ApplyT(func(v NamespaceStatusPatch) []NamespaceConditionPatch { return v.Conditions }).(NamespaceConditionPatchArrayOutput) @@ -28878,6 +32833,12 @@ func (o NamespaceStatusPatchPtrOutput) ToNamespaceStatusPatchPtrOutputWithContex return o } +func (o NamespaceStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NamespaceStatusPatch] { + return pulumix.Output[*NamespaceStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o NamespaceStatusPatchPtrOutput) Elem() NamespaceStatusPatchOutput { return o.ApplyT(func(v *NamespaceStatusPatch) NamespaceStatusPatch { if v != nil { @@ -28959,6 +32920,12 @@ func (i NodeTypeArgs) ToNodeTypeOutputWithContext(ctx context.Context) NodeTypeO return pulumi.ToOutputWithContext(ctx, i).(NodeTypeOutput) } +func (i NodeTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NodeType] { + return pulumix.Output[NodeType]{ + OutputState: i.ToNodeTypeOutputWithContext(ctx).OutputState, + } +} + // NodeTypeArrayInput is an input type that accepts NodeTypeArray and NodeTypeArrayOutput values. // You can construct a concrete instance of `NodeTypeArrayInput` via: // @@ -28984,6 +32951,12 @@ func (i NodeTypeArray) ToNodeTypeArrayOutputWithContext(ctx context.Context) Nod return pulumi.ToOutputWithContext(ctx, i).(NodeTypeArrayOutput) } +func (i NodeTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeType] { + return pulumix.Output[[]NodeType]{ + OutputState: i.ToNodeTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd). type NodeTypeOutput struct{ *pulumi.OutputState } @@ -28999,6 +32972,12 @@ func (o NodeTypeOutput) ToNodeTypeOutputWithContext(ctx context.Context) NodeTyp return o } +func (o NodeTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NodeType] { + return pulumix.Output[NodeType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NodeTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -29038,6 +33017,12 @@ func (o NodeTypeArrayOutput) ToNodeTypeArrayOutputWithContext(ctx context.Contex return o } +func (o NodeTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeType] { + return pulumix.Output[[]NodeType]{ + OutputState: o.OutputState, + } +} + func (o NodeTypeArrayOutput) Index(i pulumi.IntInput) NodeTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeType { return vs[0].([]NodeType)[vs[1].(int)] @@ -29083,6 +33068,12 @@ func (i NodeAddressArgs) ToNodeAddressOutputWithContext(ctx context.Context) Nod return pulumi.ToOutputWithContext(ctx, i).(NodeAddressOutput) } +func (i NodeAddressArgs) ToOutput(ctx context.Context) pulumix.Output[NodeAddress] { + return pulumix.Output[NodeAddress]{ + OutputState: i.ToNodeAddressOutputWithContext(ctx).OutputState, + } +} + // NodeAddressArrayInput is an input type that accepts NodeAddressArray and NodeAddressArrayOutput values. // You can construct a concrete instance of `NodeAddressArrayInput` via: // @@ -29108,6 +33099,12 @@ func (i NodeAddressArray) ToNodeAddressArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(NodeAddressArrayOutput) } +func (i NodeAddressArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeAddress] { + return pulumix.Output[[]NodeAddress]{ + OutputState: i.ToNodeAddressArrayOutputWithContext(ctx).OutputState, + } +} + // NodeAddress contains information for the node's address. type NodeAddressOutput struct{ *pulumi.OutputState } @@ -29123,6 +33120,12 @@ func (o NodeAddressOutput) ToNodeAddressOutputWithContext(ctx context.Context) N return o } +func (o NodeAddressOutput) ToOutput(ctx context.Context) pulumix.Output[NodeAddress] { + return pulumix.Output[NodeAddress]{ + OutputState: o.OutputState, + } +} + // The node address. func (o NodeAddressOutput) Address() pulumi.StringOutput { return o.ApplyT(func(v NodeAddress) string { return v.Address }).(pulumi.StringOutput) @@ -29147,6 +33150,12 @@ func (o NodeAddressArrayOutput) ToNodeAddressArrayOutputWithContext(ctx context. return o } +func (o NodeAddressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeAddress] { + return pulumix.Output[[]NodeAddress]{ + OutputState: o.OutputState, + } +} + func (o NodeAddressArrayOutput) Index(i pulumi.IntInput) NodeAddressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeAddress { return vs[0].([]NodeAddress)[vs[1].(int)] @@ -29192,6 +33201,12 @@ func (i NodeAddressPatchArgs) ToNodeAddressPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NodeAddressPatchOutput) } +func (i NodeAddressPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeAddressPatch] { + return pulumix.Output[NodeAddressPatch]{ + OutputState: i.ToNodeAddressPatchOutputWithContext(ctx).OutputState, + } +} + // NodeAddressPatchArrayInput is an input type that accepts NodeAddressPatchArray and NodeAddressPatchArrayOutput values. // You can construct a concrete instance of `NodeAddressPatchArrayInput` via: // @@ -29217,6 +33232,12 @@ func (i NodeAddressPatchArray) ToNodeAddressPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NodeAddressPatchArrayOutput) } +func (i NodeAddressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeAddressPatch] { + return pulumix.Output[[]NodeAddressPatch]{ + OutputState: i.ToNodeAddressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NodeAddress contains information for the node's address. type NodeAddressPatchOutput struct{ *pulumi.OutputState } @@ -29232,6 +33253,12 @@ func (o NodeAddressPatchOutput) ToNodeAddressPatchOutputWithContext(ctx context. return o } +func (o NodeAddressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeAddressPatch] { + return pulumix.Output[NodeAddressPatch]{ + OutputState: o.OutputState, + } +} + // The node address. func (o NodeAddressPatchOutput) Address() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeAddressPatch) *string { return v.Address }).(pulumi.StringPtrOutput) @@ -29256,6 +33283,12 @@ func (o NodeAddressPatchArrayOutput) ToNodeAddressPatchArrayOutputWithContext(ct return o } +func (o NodeAddressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeAddressPatch] { + return pulumix.Output[[]NodeAddressPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeAddressPatchArrayOutput) Index(i pulumi.IntInput) NodeAddressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeAddressPatch { return vs[0].([]NodeAddressPatch)[vs[1].(int)] @@ -29301,6 +33334,12 @@ func (i NodeAffinityArgs) ToNodeAffinityOutputWithContext(ctx context.Context) N return pulumi.ToOutputWithContext(ctx, i).(NodeAffinityOutput) } +func (i NodeAffinityArgs) ToOutput(ctx context.Context) pulumix.Output[NodeAffinity] { + return pulumix.Output[NodeAffinity]{ + OutputState: i.ToNodeAffinityOutputWithContext(ctx).OutputState, + } +} + func (i NodeAffinityArgs) ToNodeAffinityPtrOutput() NodeAffinityPtrOutput { return i.ToNodeAffinityPtrOutputWithContext(context.Background()) } @@ -29342,6 +33381,12 @@ func (i *nodeAffinityPtrType) ToNodeAffinityPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(NodeAffinityPtrOutput) } +func (i *nodeAffinityPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeAffinity] { + return pulumix.Output[*NodeAffinity]{ + OutputState: i.ToNodeAffinityPtrOutputWithContext(ctx).OutputState, + } +} + // Node affinity is a group of node affinity scheduling rules. type NodeAffinityOutput struct{ *pulumi.OutputState } @@ -29367,6 +33412,12 @@ func (o NodeAffinityOutput) ToNodeAffinityPtrOutputWithContext(ctx context.Conte }).(NodeAffinityPtrOutput) } +func (o NodeAffinityOutput) ToOutput(ctx context.Context) pulumix.Output[NodeAffinity] { + return pulumix.Output[NodeAffinity]{ + OutputState: o.OutputState, + } +} + // The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. func (o NodeAffinityOutput) PreferredDuringSchedulingIgnoredDuringExecution() PreferredSchedulingTermArrayOutput { return o.ApplyT(func(v NodeAffinity) []PreferredSchedulingTerm { @@ -29393,6 +33444,12 @@ func (o NodeAffinityPtrOutput) ToNodeAffinityPtrOutputWithContext(ctx context.Co return o } +func (o NodeAffinityPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeAffinity] { + return pulumix.Output[*NodeAffinity]{ + OutputState: o.OutputState, + } +} + func (o NodeAffinityPtrOutput) Elem() NodeAffinityOutput { return o.ApplyT(func(v *NodeAffinity) NodeAffinity { if v != nil { @@ -29462,6 +33519,12 @@ func (i NodeAffinityPatchArgs) ToNodeAffinityPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NodeAffinityPatchOutput) } +func (i NodeAffinityPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeAffinityPatch] { + return pulumix.Output[NodeAffinityPatch]{ + OutputState: i.ToNodeAffinityPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeAffinityPatchArgs) ToNodeAffinityPatchPtrOutput() NodeAffinityPatchPtrOutput { return i.ToNodeAffinityPatchPtrOutputWithContext(context.Background()) } @@ -29503,6 +33566,12 @@ func (i *nodeAffinityPatchPtrType) ToNodeAffinityPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(NodeAffinityPatchPtrOutput) } +func (i *nodeAffinityPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeAffinityPatch] { + return pulumix.Output[*NodeAffinityPatch]{ + OutputState: i.ToNodeAffinityPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Node affinity is a group of node affinity scheduling rules. type NodeAffinityPatchOutput struct{ *pulumi.OutputState } @@ -29528,6 +33597,12 @@ func (o NodeAffinityPatchOutput) ToNodeAffinityPatchPtrOutputWithContext(ctx con }).(NodeAffinityPatchPtrOutput) } +func (o NodeAffinityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeAffinityPatch] { + return pulumix.Output[NodeAffinityPatch]{ + OutputState: o.OutputState, + } +} + // The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. func (o NodeAffinityPatchOutput) PreferredDuringSchedulingIgnoredDuringExecution() PreferredSchedulingTermPatchArrayOutput { return o.ApplyT(func(v NodeAffinityPatch) []PreferredSchedulingTermPatch { @@ -29554,6 +33629,12 @@ func (o NodeAffinityPatchPtrOutput) ToNodeAffinityPatchPtrOutputWithContext(ctx return o } +func (o NodeAffinityPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeAffinityPatch] { + return pulumix.Output[*NodeAffinityPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeAffinityPatchPtrOutput) Elem() NodeAffinityPatchOutput { return o.ApplyT(func(v *NodeAffinityPatch) NodeAffinityPatch { if v != nil { @@ -29639,6 +33720,12 @@ func (i NodeConditionArgs) ToNodeConditionOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(NodeConditionOutput) } +func (i NodeConditionArgs) ToOutput(ctx context.Context) pulumix.Output[NodeCondition] { + return pulumix.Output[NodeCondition]{ + OutputState: i.ToNodeConditionOutputWithContext(ctx).OutputState, + } +} + // NodeConditionArrayInput is an input type that accepts NodeConditionArray and NodeConditionArrayOutput values. // You can construct a concrete instance of `NodeConditionArrayInput` via: // @@ -29664,6 +33751,12 @@ func (i NodeConditionArray) ToNodeConditionArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NodeConditionArrayOutput) } +func (i NodeConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeCondition] { + return pulumix.Output[[]NodeCondition]{ + OutputState: i.ToNodeConditionArrayOutputWithContext(ctx).OutputState, + } +} + // NodeCondition contains condition information for a node. type NodeConditionOutput struct{ *pulumi.OutputState } @@ -29679,6 +33772,12 @@ func (o NodeConditionOutput) ToNodeConditionOutputWithContext(ctx context.Contex return o } +func (o NodeConditionOutput) ToOutput(ctx context.Context) pulumix.Output[NodeCondition] { + return pulumix.Output[NodeCondition]{ + OutputState: o.OutputState, + } +} + // Last time we got an update on a given condition. func (o NodeConditionOutput) LastHeartbeatTime() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeCondition) *string { return v.LastHeartbeatTime }).(pulumi.StringPtrOutput) @@ -29723,6 +33822,12 @@ func (o NodeConditionArrayOutput) ToNodeConditionArrayOutputWithContext(ctx cont return o } +func (o NodeConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeCondition] { + return pulumix.Output[[]NodeCondition]{ + OutputState: o.OutputState, + } +} + func (o NodeConditionArrayOutput) Index(i pulumi.IntInput) NodeConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeCondition { return vs[0].([]NodeCondition)[vs[1].(int)] @@ -29784,6 +33889,12 @@ func (i NodeConditionPatchArgs) ToNodeConditionPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NodeConditionPatchOutput) } +func (i NodeConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeConditionPatch] { + return pulumix.Output[NodeConditionPatch]{ + OutputState: i.ToNodeConditionPatchOutputWithContext(ctx).OutputState, + } +} + // NodeConditionPatchArrayInput is an input type that accepts NodeConditionPatchArray and NodeConditionPatchArrayOutput values. // You can construct a concrete instance of `NodeConditionPatchArrayInput` via: // @@ -29809,6 +33920,12 @@ func (i NodeConditionPatchArray) ToNodeConditionPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NodeConditionPatchArrayOutput) } +func (i NodeConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeConditionPatch] { + return pulumix.Output[[]NodeConditionPatch]{ + OutputState: i.ToNodeConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NodeCondition contains condition information for a node. type NodeConditionPatchOutput struct{ *pulumi.OutputState } @@ -29824,6 +33941,12 @@ func (o NodeConditionPatchOutput) ToNodeConditionPatchOutputWithContext(ctx cont return o } +func (o NodeConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeConditionPatch] { + return pulumix.Output[NodeConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time we got an update on a given condition. func (o NodeConditionPatchOutput) LastHeartbeatTime() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeConditionPatch) *string { return v.LastHeartbeatTime }).(pulumi.StringPtrOutput) @@ -29868,6 +33991,12 @@ func (o NodeConditionPatchArrayOutput) ToNodeConditionPatchArrayOutputWithContex return o } +func (o NodeConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeConditionPatch] { + return pulumix.Output[[]NodeConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeConditionPatchArrayOutput) Index(i pulumi.IntInput) NodeConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeConditionPatch { return vs[0].([]NodeConditionPatch)[vs[1].(int)] @@ -29909,6 +34038,12 @@ func (i NodeConfigSourceArgs) ToNodeConfigSourceOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NodeConfigSourceOutput) } +func (i NodeConfigSourceArgs) ToOutput(ctx context.Context) pulumix.Output[NodeConfigSource] { + return pulumix.Output[NodeConfigSource]{ + OutputState: i.ToNodeConfigSourceOutputWithContext(ctx).OutputState, + } +} + func (i NodeConfigSourceArgs) ToNodeConfigSourcePtrOutput() NodeConfigSourcePtrOutput { return i.ToNodeConfigSourcePtrOutputWithContext(context.Background()) } @@ -29950,6 +34085,12 @@ func (i *nodeConfigSourcePtrType) ToNodeConfigSourcePtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(NodeConfigSourcePtrOutput) } +func (i *nodeConfigSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigSource] { + return pulumix.Output[*NodeConfigSource]{ + OutputState: i.ToNodeConfigSourcePtrOutputWithContext(ctx).OutputState, + } +} + // NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. This API is deprecated since 1.22 type NodeConfigSourceOutput struct{ *pulumi.OutputState } @@ -29975,6 +34116,12 @@ func (o NodeConfigSourceOutput) ToNodeConfigSourcePtrOutputWithContext(ctx conte }).(NodeConfigSourcePtrOutput) } +func (o NodeConfigSourceOutput) ToOutput(ctx context.Context) pulumix.Output[NodeConfigSource] { + return pulumix.Output[NodeConfigSource]{ + OutputState: o.OutputState, + } +} + // ConfigMap is a reference to a Node's ConfigMap func (o NodeConfigSourceOutput) ConfigMap() ConfigMapNodeConfigSourcePtrOutput { return o.ApplyT(func(v NodeConfigSource) *ConfigMapNodeConfigSource { return v.ConfigMap }).(ConfigMapNodeConfigSourcePtrOutput) @@ -29994,6 +34141,12 @@ func (o NodeConfigSourcePtrOutput) ToNodeConfigSourcePtrOutputWithContext(ctx co return o } +func (o NodeConfigSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigSource] { + return pulumix.Output[*NodeConfigSource]{ + OutputState: o.OutputState, + } +} + func (o NodeConfigSourcePtrOutput) Elem() NodeConfigSourceOutput { return o.ApplyT(func(v *NodeConfigSource) NodeConfigSource { if v != nil { @@ -30049,6 +34202,12 @@ func (i NodeConfigSourcePatchArgs) ToNodeConfigSourcePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NodeConfigSourcePatchOutput) } +func (i NodeConfigSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeConfigSourcePatch] { + return pulumix.Output[NodeConfigSourcePatch]{ + OutputState: i.ToNodeConfigSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeConfigSourcePatchArgs) ToNodeConfigSourcePatchPtrOutput() NodeConfigSourcePatchPtrOutput { return i.ToNodeConfigSourcePatchPtrOutputWithContext(context.Background()) } @@ -30090,6 +34249,12 @@ func (i *nodeConfigSourcePatchPtrType) ToNodeConfigSourcePatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(NodeConfigSourcePatchPtrOutput) } +func (i *nodeConfigSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigSourcePatch] { + return pulumix.Output[*NodeConfigSourcePatch]{ + OutputState: i.ToNodeConfigSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. This API is deprecated since 1.22 type NodeConfigSourcePatchOutput struct{ *pulumi.OutputState } @@ -30115,6 +34280,12 @@ func (o NodeConfigSourcePatchOutput) ToNodeConfigSourcePatchPtrOutputWithContext }).(NodeConfigSourcePatchPtrOutput) } +func (o NodeConfigSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeConfigSourcePatch] { + return pulumix.Output[NodeConfigSourcePatch]{ + OutputState: o.OutputState, + } +} + // ConfigMap is a reference to a Node's ConfigMap func (o NodeConfigSourcePatchOutput) ConfigMap() ConfigMapNodeConfigSourcePatchPtrOutput { return o.ApplyT(func(v NodeConfigSourcePatch) *ConfigMapNodeConfigSourcePatch { return v.ConfigMap }).(ConfigMapNodeConfigSourcePatchPtrOutput) @@ -30134,6 +34305,12 @@ func (o NodeConfigSourcePatchPtrOutput) ToNodeConfigSourcePatchPtrOutputWithCont return o } +func (o NodeConfigSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigSourcePatch] { + return pulumix.Output[*NodeConfigSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o NodeConfigSourcePatchPtrOutput) Elem() NodeConfigSourcePatchOutput { return o.ApplyT(func(v *NodeConfigSourcePatch) NodeConfigSourcePatch { if v != nil { @@ -30201,6 +34378,12 @@ func (i NodeConfigStatusArgs) ToNodeConfigStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NodeConfigStatusOutput) } +func (i NodeConfigStatusArgs) ToOutput(ctx context.Context) pulumix.Output[NodeConfigStatus] { + return pulumix.Output[NodeConfigStatus]{ + OutputState: i.ToNodeConfigStatusOutputWithContext(ctx).OutputState, + } +} + func (i NodeConfigStatusArgs) ToNodeConfigStatusPtrOutput() NodeConfigStatusPtrOutput { return i.ToNodeConfigStatusPtrOutputWithContext(context.Background()) } @@ -30242,6 +34425,12 @@ func (i *nodeConfigStatusPtrType) ToNodeConfigStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(NodeConfigStatusPtrOutput) } +func (i *nodeConfigStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigStatus] { + return pulumix.Output[*NodeConfigStatus]{ + OutputState: i.ToNodeConfigStatusPtrOutputWithContext(ctx).OutputState, + } +} + // NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource. type NodeConfigStatusOutput struct{ *pulumi.OutputState } @@ -30267,6 +34456,12 @@ func (o NodeConfigStatusOutput) ToNodeConfigStatusPtrOutputWithContext(ctx conte }).(NodeConfigStatusPtrOutput) } +func (o NodeConfigStatusOutput) ToOutput(ctx context.Context) pulumix.Output[NodeConfigStatus] { + return pulumix.Output[NodeConfigStatus]{ + OutputState: o.OutputState, + } +} + // Active reports the checkpointed config the node is actively using. Active will represent either the current version of the Assigned config, or the current LastKnownGood config, depending on whether attempting to use the Assigned config results in an error. func (o NodeConfigStatusOutput) Active() NodeConfigSourcePtrOutput { return o.ApplyT(func(v NodeConfigStatus) *NodeConfigSource { return v.Active }).(NodeConfigSourcePtrOutput) @@ -30301,6 +34496,12 @@ func (o NodeConfigStatusPtrOutput) ToNodeConfigStatusPtrOutputWithContext(ctx co return o } +func (o NodeConfigStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigStatus] { + return pulumix.Output[*NodeConfigStatus]{ + OutputState: o.OutputState, + } +} + func (o NodeConfigStatusPtrOutput) Elem() NodeConfigStatusOutput { return o.ApplyT(func(v *NodeConfigStatus) NodeConfigStatus { if v != nil { @@ -30398,6 +34599,12 @@ func (i NodeConfigStatusPatchArgs) ToNodeConfigStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NodeConfigStatusPatchOutput) } +func (i NodeConfigStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeConfigStatusPatch] { + return pulumix.Output[NodeConfigStatusPatch]{ + OutputState: i.ToNodeConfigStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeConfigStatusPatchArgs) ToNodeConfigStatusPatchPtrOutput() NodeConfigStatusPatchPtrOutput { return i.ToNodeConfigStatusPatchPtrOutputWithContext(context.Background()) } @@ -30439,6 +34646,12 @@ func (i *nodeConfigStatusPatchPtrType) ToNodeConfigStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(NodeConfigStatusPatchPtrOutput) } +func (i *nodeConfigStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigStatusPatch] { + return pulumix.Output[*NodeConfigStatusPatch]{ + OutputState: i.ToNodeConfigStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource. type NodeConfigStatusPatchOutput struct{ *pulumi.OutputState } @@ -30464,6 +34677,12 @@ func (o NodeConfigStatusPatchOutput) ToNodeConfigStatusPatchPtrOutputWithContext }).(NodeConfigStatusPatchPtrOutput) } +func (o NodeConfigStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeConfigStatusPatch] { + return pulumix.Output[NodeConfigStatusPatch]{ + OutputState: o.OutputState, + } +} + // Active reports the checkpointed config the node is actively using. Active will represent either the current version of the Assigned config, or the current LastKnownGood config, depending on whether attempting to use the Assigned config results in an error. func (o NodeConfigStatusPatchOutput) Active() NodeConfigSourcePatchPtrOutput { return o.ApplyT(func(v NodeConfigStatusPatch) *NodeConfigSourcePatch { return v.Active }).(NodeConfigSourcePatchPtrOutput) @@ -30498,6 +34717,12 @@ func (o NodeConfigStatusPatchPtrOutput) ToNodeConfigStatusPatchPtrOutputWithCont return o } +func (o NodeConfigStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeConfigStatusPatch] { + return pulumix.Output[*NodeConfigStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeConfigStatusPatchPtrOutput) Elem() NodeConfigStatusPatchOutput { return o.ApplyT(func(v *NodeConfigStatusPatch) NodeConfigStatusPatch { if v != nil { @@ -30583,6 +34808,12 @@ func (i NodeDaemonEndpointsArgs) ToNodeDaemonEndpointsOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NodeDaemonEndpointsOutput) } +func (i NodeDaemonEndpointsArgs) ToOutput(ctx context.Context) pulumix.Output[NodeDaemonEndpoints] { + return pulumix.Output[NodeDaemonEndpoints]{ + OutputState: i.ToNodeDaemonEndpointsOutputWithContext(ctx).OutputState, + } +} + func (i NodeDaemonEndpointsArgs) ToNodeDaemonEndpointsPtrOutput() NodeDaemonEndpointsPtrOutput { return i.ToNodeDaemonEndpointsPtrOutputWithContext(context.Background()) } @@ -30624,6 +34855,12 @@ func (i *nodeDaemonEndpointsPtrType) ToNodeDaemonEndpointsPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(NodeDaemonEndpointsPtrOutput) } +func (i *nodeDaemonEndpointsPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeDaemonEndpoints] { + return pulumix.Output[*NodeDaemonEndpoints]{ + OutputState: i.ToNodeDaemonEndpointsPtrOutputWithContext(ctx).OutputState, + } +} + // NodeDaemonEndpoints lists ports opened by daemons running on the Node. type NodeDaemonEndpointsOutput struct{ *pulumi.OutputState } @@ -30649,6 +34886,12 @@ func (o NodeDaemonEndpointsOutput) ToNodeDaemonEndpointsPtrOutputWithContext(ctx }).(NodeDaemonEndpointsPtrOutput) } +func (o NodeDaemonEndpointsOutput) ToOutput(ctx context.Context) pulumix.Output[NodeDaemonEndpoints] { + return pulumix.Output[NodeDaemonEndpoints]{ + OutputState: o.OutputState, + } +} + // Endpoint on which Kubelet is listening. func (o NodeDaemonEndpointsOutput) KubeletEndpoint() DaemonEndpointPtrOutput { return o.ApplyT(func(v NodeDaemonEndpoints) *DaemonEndpoint { return v.KubeletEndpoint }).(DaemonEndpointPtrOutput) @@ -30668,6 +34911,12 @@ func (o NodeDaemonEndpointsPtrOutput) ToNodeDaemonEndpointsPtrOutputWithContext( return o } +func (o NodeDaemonEndpointsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeDaemonEndpoints] { + return pulumix.Output[*NodeDaemonEndpoints]{ + OutputState: o.OutputState, + } +} + func (o NodeDaemonEndpointsPtrOutput) Elem() NodeDaemonEndpointsOutput { return o.ApplyT(func(v *NodeDaemonEndpoints) NodeDaemonEndpoints { if v != nil { @@ -30723,6 +34972,12 @@ func (i NodeDaemonEndpointsPatchArgs) ToNodeDaemonEndpointsPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NodeDaemonEndpointsPatchOutput) } +func (i NodeDaemonEndpointsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeDaemonEndpointsPatch] { + return pulumix.Output[NodeDaemonEndpointsPatch]{ + OutputState: i.ToNodeDaemonEndpointsPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeDaemonEndpointsPatchArgs) ToNodeDaemonEndpointsPatchPtrOutput() NodeDaemonEndpointsPatchPtrOutput { return i.ToNodeDaemonEndpointsPatchPtrOutputWithContext(context.Background()) } @@ -30764,6 +35019,12 @@ func (i *nodeDaemonEndpointsPatchPtrType) ToNodeDaemonEndpointsPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(NodeDaemonEndpointsPatchPtrOutput) } +func (i *nodeDaemonEndpointsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeDaemonEndpointsPatch] { + return pulumix.Output[*NodeDaemonEndpointsPatch]{ + OutputState: i.ToNodeDaemonEndpointsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeDaemonEndpoints lists ports opened by daemons running on the Node. type NodeDaemonEndpointsPatchOutput struct{ *pulumi.OutputState } @@ -30789,6 +35050,12 @@ func (o NodeDaemonEndpointsPatchOutput) ToNodeDaemonEndpointsPatchPtrOutputWithC }).(NodeDaemonEndpointsPatchPtrOutput) } +func (o NodeDaemonEndpointsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeDaemonEndpointsPatch] { + return pulumix.Output[NodeDaemonEndpointsPatch]{ + OutputState: o.OutputState, + } +} + // Endpoint on which Kubelet is listening. func (o NodeDaemonEndpointsPatchOutput) KubeletEndpoint() DaemonEndpointPatchPtrOutput { return o.ApplyT(func(v NodeDaemonEndpointsPatch) *DaemonEndpointPatch { return v.KubeletEndpoint }).(DaemonEndpointPatchPtrOutput) @@ -30808,6 +35075,12 @@ func (o NodeDaemonEndpointsPatchPtrOutput) ToNodeDaemonEndpointsPatchPtrOutputWi return o } +func (o NodeDaemonEndpointsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeDaemonEndpointsPatch] { + return pulumix.Output[*NodeDaemonEndpointsPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeDaemonEndpointsPatchPtrOutput) Elem() NodeDaemonEndpointsPatchOutput { return o.ApplyT(func(v *NodeDaemonEndpointsPatch) NodeDaemonEndpointsPatch { if v != nil { @@ -30875,6 +35148,12 @@ func (i NodeListTypeArgs) ToNodeListTypeOutputWithContext(ctx context.Context) N return pulumi.ToOutputWithContext(ctx, i).(NodeListTypeOutput) } +func (i NodeListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NodeListType] { + return pulumix.Output[NodeListType]{ + OutputState: i.ToNodeListTypeOutputWithContext(ctx).OutputState, + } +} + // NodeList is the whole list of all Nodes which have been registered with master. type NodeListTypeOutput struct{ *pulumi.OutputState } @@ -30890,6 +35169,12 @@ func (o NodeListTypeOutput) ToNodeListTypeOutputWithContext(ctx context.Context) return o } +func (o NodeListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NodeListType] { + return pulumix.Output[NodeListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NodeListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -30961,6 +35246,12 @@ func (i NodePatchTypeArgs) ToNodePatchTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(NodePatchTypeOutput) } +func (i NodePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NodePatchType] { + return pulumix.Output[NodePatchType]{ + OutputState: i.ToNodePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd). type NodePatchTypeOutput struct{ *pulumi.OutputState } @@ -30976,6 +35267,12 @@ func (o NodePatchTypeOutput) ToNodePatchTypeOutputWithContext(ctx context.Contex return o } +func (o NodePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NodePatchType] { + return pulumix.Output[NodePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NodePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NodePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -31036,6 +35333,12 @@ func (i NodeSelectorArgs) ToNodeSelectorOutputWithContext(ctx context.Context) N return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorOutput) } +func (i NodeSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSelector] { + return pulumix.Output[NodeSelector]{ + OutputState: i.ToNodeSelectorOutputWithContext(ctx).OutputState, + } +} + func (i NodeSelectorArgs) ToNodeSelectorPtrOutput() NodeSelectorPtrOutput { return i.ToNodeSelectorPtrOutputWithContext(context.Background()) } @@ -31077,6 +35380,12 @@ func (i *nodeSelectorPtrType) ToNodeSelectorPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorPtrOutput) } +func (i *nodeSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSelector] { + return pulumix.Output[*NodeSelector]{ + OutputState: i.ToNodeSelectorPtrOutputWithContext(ctx).OutputState, + } +} + // A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms. type NodeSelectorOutput struct{ *pulumi.OutputState } @@ -31102,6 +35411,12 @@ func (o NodeSelectorOutput) ToNodeSelectorPtrOutputWithContext(ctx context.Conte }).(NodeSelectorPtrOutput) } +func (o NodeSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSelector] { + return pulumix.Output[NodeSelector]{ + OutputState: o.OutputState, + } +} + // Required. A list of node selector terms. The terms are ORed. func (o NodeSelectorOutput) NodeSelectorTerms() NodeSelectorTermArrayOutput { return o.ApplyT(func(v NodeSelector) []NodeSelectorTerm { return v.NodeSelectorTerms }).(NodeSelectorTermArrayOutput) @@ -31121,6 +35436,12 @@ func (o NodeSelectorPtrOutput) ToNodeSelectorPtrOutputWithContext(ctx context.Co return o } +func (o NodeSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSelector] { + return pulumix.Output[*NodeSelector]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorPtrOutput) Elem() NodeSelectorOutput { return o.ApplyT(func(v *NodeSelector) NodeSelector { if v != nil { @@ -31176,6 +35497,12 @@ func (i NodeSelectorPatchArgs) ToNodeSelectorPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorPatchOutput) } +func (i NodeSelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorPatch] { + return pulumix.Output[NodeSelectorPatch]{ + OutputState: i.ToNodeSelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeSelectorPatchArgs) ToNodeSelectorPatchPtrOutput() NodeSelectorPatchPtrOutput { return i.ToNodeSelectorPatchPtrOutputWithContext(context.Background()) } @@ -31217,6 +35544,12 @@ func (i *nodeSelectorPatchPtrType) ToNodeSelectorPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorPatchPtrOutput) } +func (i *nodeSelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSelectorPatch] { + return pulumix.Output[*NodeSelectorPatch]{ + OutputState: i.ToNodeSelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms. type NodeSelectorPatchOutput struct{ *pulumi.OutputState } @@ -31242,6 +35575,12 @@ func (o NodeSelectorPatchOutput) ToNodeSelectorPatchPtrOutputWithContext(ctx con }).(NodeSelectorPatchPtrOutput) } +func (o NodeSelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorPatch] { + return pulumix.Output[NodeSelectorPatch]{ + OutputState: o.OutputState, + } +} + // Required. A list of node selector terms. The terms are ORed. func (o NodeSelectorPatchOutput) NodeSelectorTerms() NodeSelectorTermPatchArrayOutput { return o.ApplyT(func(v NodeSelectorPatch) []NodeSelectorTermPatch { return v.NodeSelectorTerms }).(NodeSelectorTermPatchArrayOutput) @@ -31261,6 +35600,12 @@ func (o NodeSelectorPatchPtrOutput) ToNodeSelectorPatchPtrOutputWithContext(ctx return o } +func (o NodeSelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSelectorPatch] { + return pulumix.Output[*NodeSelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorPatchPtrOutput) Elem() NodeSelectorPatchOutput { return o.ApplyT(func(v *NodeSelectorPatch) NodeSelectorPatch { if v != nil { @@ -31324,6 +35669,12 @@ func (i NodeSelectorRequirementArgs) ToNodeSelectorRequirementOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorRequirementOutput) } +func (i NodeSelectorRequirementArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorRequirement] { + return pulumix.Output[NodeSelectorRequirement]{ + OutputState: i.ToNodeSelectorRequirementOutputWithContext(ctx).OutputState, + } +} + // NodeSelectorRequirementArrayInput is an input type that accepts NodeSelectorRequirementArray and NodeSelectorRequirementArrayOutput values. // You can construct a concrete instance of `NodeSelectorRequirementArrayInput` via: // @@ -31349,6 +35700,12 @@ func (i NodeSelectorRequirementArray) ToNodeSelectorRequirementArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorRequirementArrayOutput) } +func (i NodeSelectorRequirementArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorRequirement] { + return pulumix.Output[[]NodeSelectorRequirement]{ + OutputState: i.ToNodeSelectorRequirementArrayOutputWithContext(ctx).OutputState, + } +} + // A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. type NodeSelectorRequirementOutput struct{ *pulumi.OutputState } @@ -31364,6 +35721,12 @@ func (o NodeSelectorRequirementOutput) ToNodeSelectorRequirementOutputWithContex return o } +func (o NodeSelectorRequirementOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorRequirement] { + return pulumix.Output[NodeSelectorRequirement]{ + OutputState: o.OutputState, + } +} + // The label key that the selector applies to. func (o NodeSelectorRequirementOutput) Key() pulumi.StringOutput { return o.ApplyT(func(v NodeSelectorRequirement) string { return v.Key }).(pulumi.StringOutput) @@ -31393,6 +35756,12 @@ func (o NodeSelectorRequirementArrayOutput) ToNodeSelectorRequirementArrayOutput return o } +func (o NodeSelectorRequirementArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorRequirement] { + return pulumix.Output[[]NodeSelectorRequirement]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorRequirementArrayOutput) Index(i pulumi.IntInput) NodeSelectorRequirementOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeSelectorRequirement { return vs[0].([]NodeSelectorRequirement)[vs[1].(int)] @@ -31442,6 +35811,12 @@ func (i NodeSelectorRequirementPatchArgs) ToNodeSelectorRequirementPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorRequirementPatchOutput) } +func (i NodeSelectorRequirementPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorRequirementPatch] { + return pulumix.Output[NodeSelectorRequirementPatch]{ + OutputState: i.ToNodeSelectorRequirementPatchOutputWithContext(ctx).OutputState, + } +} + // NodeSelectorRequirementPatchArrayInput is an input type that accepts NodeSelectorRequirementPatchArray and NodeSelectorRequirementPatchArrayOutput values. // You can construct a concrete instance of `NodeSelectorRequirementPatchArrayInput` via: // @@ -31467,6 +35842,12 @@ func (i NodeSelectorRequirementPatchArray) ToNodeSelectorRequirementPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorRequirementPatchArrayOutput) } +func (i NodeSelectorRequirementPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorRequirementPatch] { + return pulumix.Output[[]NodeSelectorRequirementPatch]{ + OutputState: i.ToNodeSelectorRequirementPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. type NodeSelectorRequirementPatchOutput struct{ *pulumi.OutputState } @@ -31482,6 +35863,12 @@ func (o NodeSelectorRequirementPatchOutput) ToNodeSelectorRequirementPatchOutput return o } +func (o NodeSelectorRequirementPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorRequirementPatch] { + return pulumix.Output[NodeSelectorRequirementPatch]{ + OutputState: o.OutputState, + } +} + // The label key that the selector applies to. func (o NodeSelectorRequirementPatchOutput) Key() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeSelectorRequirementPatch) *string { return v.Key }).(pulumi.StringPtrOutput) @@ -31511,6 +35898,12 @@ func (o NodeSelectorRequirementPatchArrayOutput) ToNodeSelectorRequirementPatchA return o } +func (o NodeSelectorRequirementPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorRequirementPatch] { + return pulumix.Output[[]NodeSelectorRequirementPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorRequirementPatchArrayOutput) Index(i pulumi.IntInput) NodeSelectorRequirementPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeSelectorRequirementPatch { return vs[0].([]NodeSelectorRequirementPatch)[vs[1].(int)] @@ -31556,6 +35949,12 @@ func (i NodeSelectorTermArgs) ToNodeSelectorTermOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorTermOutput) } +func (i NodeSelectorTermArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorTerm] { + return pulumix.Output[NodeSelectorTerm]{ + OutputState: i.ToNodeSelectorTermOutputWithContext(ctx).OutputState, + } +} + // NodeSelectorTermArrayInput is an input type that accepts NodeSelectorTermArray and NodeSelectorTermArrayOutput values. // You can construct a concrete instance of `NodeSelectorTermArrayInput` via: // @@ -31581,6 +35980,12 @@ func (i NodeSelectorTermArray) ToNodeSelectorTermArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorTermArrayOutput) } +func (i NodeSelectorTermArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorTerm] { + return pulumix.Output[[]NodeSelectorTerm]{ + OutputState: i.ToNodeSelectorTermArrayOutputWithContext(ctx).OutputState, + } +} + // A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. type NodeSelectorTermOutput struct{ *pulumi.OutputState } @@ -31596,6 +36001,12 @@ func (o NodeSelectorTermOutput) ToNodeSelectorTermOutputWithContext(ctx context. return o } +func (o NodeSelectorTermOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorTerm] { + return pulumix.Output[NodeSelectorTerm]{ + OutputState: o.OutputState, + } +} + // A list of node selector requirements by node's labels. func (o NodeSelectorTermOutput) MatchExpressions() NodeSelectorRequirementArrayOutput { return o.ApplyT(func(v NodeSelectorTerm) []NodeSelectorRequirement { return v.MatchExpressions }).(NodeSelectorRequirementArrayOutput) @@ -31620,6 +36031,12 @@ func (o NodeSelectorTermArrayOutput) ToNodeSelectorTermArrayOutputWithContext(ct return o } +func (o NodeSelectorTermArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorTerm] { + return pulumix.Output[[]NodeSelectorTerm]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorTermArrayOutput) Index(i pulumi.IntInput) NodeSelectorTermOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeSelectorTerm { return vs[0].([]NodeSelectorTerm)[vs[1].(int)] @@ -31665,6 +36082,12 @@ func (i NodeSelectorTermPatchArgs) ToNodeSelectorTermPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorTermPatchOutput) } +func (i NodeSelectorTermPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorTermPatch] { + return pulumix.Output[NodeSelectorTermPatch]{ + OutputState: i.ToNodeSelectorTermPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeSelectorTermPatchArgs) ToNodeSelectorTermPatchPtrOutput() NodeSelectorTermPatchPtrOutput { return i.ToNodeSelectorTermPatchPtrOutputWithContext(context.Background()) } @@ -31706,6 +36129,12 @@ func (i *nodeSelectorTermPatchPtrType) ToNodeSelectorTermPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorTermPatchPtrOutput) } +func (i *nodeSelectorTermPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSelectorTermPatch] { + return pulumix.Output[*NodeSelectorTermPatch]{ + OutputState: i.ToNodeSelectorTermPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeSelectorTermPatchArrayInput is an input type that accepts NodeSelectorTermPatchArray and NodeSelectorTermPatchArrayOutput values. // You can construct a concrete instance of `NodeSelectorTermPatchArrayInput` via: // @@ -31731,6 +36160,12 @@ func (i NodeSelectorTermPatchArray) ToNodeSelectorTermPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NodeSelectorTermPatchArrayOutput) } +func (i NodeSelectorTermPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorTermPatch] { + return pulumix.Output[[]NodeSelectorTermPatch]{ + OutputState: i.ToNodeSelectorTermPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. type NodeSelectorTermPatchOutput struct{ *pulumi.OutputState } @@ -31756,6 +36191,12 @@ func (o NodeSelectorTermPatchOutput) ToNodeSelectorTermPatchPtrOutputWithContext }).(NodeSelectorTermPatchPtrOutput) } +func (o NodeSelectorTermPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSelectorTermPatch] { + return pulumix.Output[NodeSelectorTermPatch]{ + OutputState: o.OutputState, + } +} + // A list of node selector requirements by node's labels. func (o NodeSelectorTermPatchOutput) MatchExpressions() NodeSelectorRequirementPatchArrayOutput { return o.ApplyT(func(v NodeSelectorTermPatch) []NodeSelectorRequirementPatch { return v.MatchExpressions }).(NodeSelectorRequirementPatchArrayOutput) @@ -31780,6 +36221,12 @@ func (o NodeSelectorTermPatchPtrOutput) ToNodeSelectorTermPatchPtrOutputWithCont return o } +func (o NodeSelectorTermPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSelectorTermPatch] { + return pulumix.Output[*NodeSelectorTermPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorTermPatchPtrOutput) Elem() NodeSelectorTermPatchOutput { return o.ApplyT(func(v *NodeSelectorTermPatch) NodeSelectorTermPatch { if v != nil { @@ -31824,6 +36271,12 @@ func (o NodeSelectorTermPatchArrayOutput) ToNodeSelectorTermPatchArrayOutputWith return o } +func (o NodeSelectorTermPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NodeSelectorTermPatch] { + return pulumix.Output[[]NodeSelectorTermPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeSelectorTermPatchArrayOutput) Index(i pulumi.IntInput) NodeSelectorTermPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NodeSelectorTermPatch { return vs[0].([]NodeSelectorTermPatch)[vs[1].(int)] @@ -31889,6 +36342,12 @@ func (i NodeSpecArgs) ToNodeSpecOutputWithContext(ctx context.Context) NodeSpecO return pulumi.ToOutputWithContext(ctx, i).(NodeSpecOutput) } +func (i NodeSpecArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSpec] { + return pulumix.Output[NodeSpec]{ + OutputState: i.ToNodeSpecOutputWithContext(ctx).OutputState, + } +} + func (i NodeSpecArgs) ToNodeSpecPtrOutput() NodeSpecPtrOutput { return i.ToNodeSpecPtrOutputWithContext(context.Background()) } @@ -31930,6 +36389,12 @@ func (i *nodeSpecPtrType) ToNodeSpecPtrOutputWithContext(ctx context.Context) No return pulumi.ToOutputWithContext(ctx, i).(NodeSpecPtrOutput) } +func (i *nodeSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSpec] { + return pulumix.Output[*NodeSpec]{ + OutputState: i.ToNodeSpecPtrOutputWithContext(ctx).OutputState, + } +} + // NodeSpec describes the attributes that a node is created with. type NodeSpecOutput struct{ *pulumi.OutputState } @@ -31955,6 +36420,12 @@ func (o NodeSpecOutput) ToNodeSpecPtrOutputWithContext(ctx context.Context) Node }).(NodeSpecPtrOutput) } +func (o NodeSpecOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSpec] { + return pulumix.Output[NodeSpec]{ + OutputState: o.OutputState, + } +} + // Deprecated: Previously used to specify the source of the node's configuration for the DynamicKubeletConfig feature. This feature is removed. func (o NodeSpecOutput) ConfigSource() NodeConfigSourcePtrOutput { return o.ApplyT(func(v NodeSpec) *NodeConfigSource { return v.ConfigSource }).(NodeConfigSourcePtrOutput) @@ -32004,6 +36475,12 @@ func (o NodeSpecPtrOutput) ToNodeSpecPtrOutputWithContext(ctx context.Context) N return o } +func (o NodeSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSpec] { + return pulumix.Output[*NodeSpec]{ + OutputState: o.OutputState, + } +} + func (o NodeSpecPtrOutput) Elem() NodeSpecOutput { return o.ApplyT(func(v *NodeSpec) NodeSpec { if v != nil { @@ -32143,6 +36620,12 @@ func (i NodeSpecPatchArgs) ToNodeSpecPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(NodeSpecPatchOutput) } +func (i NodeSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSpecPatch] { + return pulumix.Output[NodeSpecPatch]{ + OutputState: i.ToNodeSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeSpecPatchArgs) ToNodeSpecPatchPtrOutput() NodeSpecPatchPtrOutput { return i.ToNodeSpecPatchPtrOutputWithContext(context.Background()) } @@ -32184,6 +36667,12 @@ func (i *nodeSpecPatchPtrType) ToNodeSpecPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(NodeSpecPatchPtrOutput) } +func (i *nodeSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSpecPatch] { + return pulumix.Output[*NodeSpecPatch]{ + OutputState: i.ToNodeSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeSpec describes the attributes that a node is created with. type NodeSpecPatchOutput struct{ *pulumi.OutputState } @@ -32209,6 +36698,12 @@ func (o NodeSpecPatchOutput) ToNodeSpecPatchPtrOutputWithContext(ctx context.Con }).(NodeSpecPatchPtrOutput) } +func (o NodeSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSpecPatch] { + return pulumix.Output[NodeSpecPatch]{ + OutputState: o.OutputState, + } +} + // Deprecated: Previously used to specify the source of the node's configuration for the DynamicKubeletConfig feature. This feature is removed. func (o NodeSpecPatchOutput) ConfigSource() NodeConfigSourcePatchPtrOutput { return o.ApplyT(func(v NodeSpecPatch) *NodeConfigSourcePatch { return v.ConfigSource }).(NodeConfigSourcePatchPtrOutput) @@ -32258,6 +36753,12 @@ func (o NodeSpecPatchPtrOutput) ToNodeSpecPatchPtrOutputWithContext(ctx context. return o } +func (o NodeSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSpecPatch] { + return pulumix.Output[*NodeSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeSpecPatchPtrOutput) Elem() NodeSpecPatchOutput { return o.ApplyT(func(v *NodeSpecPatch) NodeSpecPatch { if v != nil { @@ -32413,6 +36914,12 @@ func (i NodeStatusArgs) ToNodeStatusOutputWithContext(ctx context.Context) NodeS return pulumi.ToOutputWithContext(ctx, i).(NodeStatusOutput) } +func (i NodeStatusArgs) ToOutput(ctx context.Context) pulumix.Output[NodeStatus] { + return pulumix.Output[NodeStatus]{ + OutputState: i.ToNodeStatusOutputWithContext(ctx).OutputState, + } +} + func (i NodeStatusArgs) ToNodeStatusPtrOutput() NodeStatusPtrOutput { return i.ToNodeStatusPtrOutputWithContext(context.Background()) } @@ -32454,6 +36961,12 @@ func (i *nodeStatusPtrType) ToNodeStatusPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(NodeStatusPtrOutput) } +func (i *nodeStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeStatus] { + return pulumix.Output[*NodeStatus]{ + OutputState: i.ToNodeStatusPtrOutputWithContext(ctx).OutputState, + } +} + // NodeStatus is information about the current status of a node. type NodeStatusOutput struct{ *pulumi.OutputState } @@ -32479,6 +36992,12 @@ func (o NodeStatusOutput) ToNodeStatusPtrOutputWithContext(ctx context.Context) }).(NodeStatusPtrOutput) } +func (o NodeStatusOutput) ToOutput(ctx context.Context) pulumix.Output[NodeStatus] { + return pulumix.Output[NodeStatus]{ + OutputState: o.OutputState, + } +} + // List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See https://pr.k8s.io/79391 for an example. Consumers should assume that addresses can change during the lifetime of a Node. However, there are some exceptions where this may not be possible, such as Pods that inherit a Node's address in its own status or consumers of the downward API (status.hostIP). func (o NodeStatusOutput) Addresses() NodeAddressArrayOutput { return o.ApplyT(func(v NodeStatus) []NodeAddress { return v.Addresses }).(NodeAddressArrayOutput) @@ -32548,6 +37067,12 @@ func (o NodeStatusPtrOutput) ToNodeStatusPtrOutputWithContext(ctx context.Contex return o } +func (o NodeStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeStatus] { + return pulumix.Output[*NodeStatus]{ + OutputState: o.OutputState, + } +} + func (o NodeStatusPtrOutput) Elem() NodeStatusOutput { return o.ApplyT(func(v *NodeStatus) NodeStatus { if v != nil { @@ -32743,6 +37268,12 @@ func (i NodeStatusPatchArgs) ToNodeStatusPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(NodeStatusPatchOutput) } +func (i NodeStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeStatusPatch] { + return pulumix.Output[NodeStatusPatch]{ + OutputState: i.ToNodeStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeStatusPatchArgs) ToNodeStatusPatchPtrOutput() NodeStatusPatchPtrOutput { return i.ToNodeStatusPatchPtrOutputWithContext(context.Background()) } @@ -32784,6 +37315,12 @@ func (i *nodeStatusPatchPtrType) ToNodeStatusPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(NodeStatusPatchPtrOutput) } +func (i *nodeStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeStatusPatch] { + return pulumix.Output[*NodeStatusPatch]{ + OutputState: i.ToNodeStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeStatus is information about the current status of a node. type NodeStatusPatchOutput struct{ *pulumi.OutputState } @@ -32809,6 +37346,12 @@ func (o NodeStatusPatchOutput) ToNodeStatusPatchPtrOutputWithContext(ctx context }).(NodeStatusPatchPtrOutput) } +func (o NodeStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeStatusPatch] { + return pulumix.Output[NodeStatusPatch]{ + OutputState: o.OutputState, + } +} + // List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See https://pr.k8s.io/79391 for an example. Consumers should assume that addresses can change during the lifetime of a Node. However, there are some exceptions where this may not be possible, such as Pods that inherit a Node's address in its own status or consumers of the downward API (status.hostIP). func (o NodeStatusPatchOutput) Addresses() NodeAddressPatchArrayOutput { return o.ApplyT(func(v NodeStatusPatch) []NodeAddressPatch { return v.Addresses }).(NodeAddressPatchArrayOutput) @@ -32878,6 +37421,12 @@ func (o NodeStatusPatchPtrOutput) ToNodeStatusPatchPtrOutputWithContext(ctx cont return o } +func (o NodeStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeStatusPatch] { + return pulumix.Output[*NodeStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeStatusPatchPtrOutput) Elem() NodeStatusPatchOutput { return o.ApplyT(func(v *NodeStatusPatch) NodeStatusPatch { if v != nil { @@ -33069,6 +37618,12 @@ func (i NodeSystemInfoArgs) ToNodeSystemInfoOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(NodeSystemInfoOutput) } +func (i NodeSystemInfoArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSystemInfo] { + return pulumix.Output[NodeSystemInfo]{ + OutputState: i.ToNodeSystemInfoOutputWithContext(ctx).OutputState, + } +} + func (i NodeSystemInfoArgs) ToNodeSystemInfoPtrOutput() NodeSystemInfoPtrOutput { return i.ToNodeSystemInfoPtrOutputWithContext(context.Background()) } @@ -33110,6 +37665,12 @@ func (i *nodeSystemInfoPtrType) ToNodeSystemInfoPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(NodeSystemInfoPtrOutput) } +func (i *nodeSystemInfoPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSystemInfo] { + return pulumix.Output[*NodeSystemInfo]{ + OutputState: i.ToNodeSystemInfoPtrOutputWithContext(ctx).OutputState, + } +} + // NodeSystemInfo is a set of ids/uuids to uniquely identify the node. type NodeSystemInfoOutput struct{ *pulumi.OutputState } @@ -33135,6 +37696,12 @@ func (o NodeSystemInfoOutput) ToNodeSystemInfoPtrOutputWithContext(ctx context.C }).(NodeSystemInfoPtrOutput) } +func (o NodeSystemInfoOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSystemInfo] { + return pulumix.Output[NodeSystemInfo]{ + OutputState: o.OutputState, + } +} + // The Architecture reported by the node func (o NodeSystemInfoOutput) Architecture() pulumi.StringOutput { return o.ApplyT(func(v NodeSystemInfo) string { return v.Architecture }).(pulumi.StringOutput) @@ -33199,6 +37766,12 @@ func (o NodeSystemInfoPtrOutput) ToNodeSystemInfoPtrOutputWithContext(ctx contex return o } +func (o NodeSystemInfoPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSystemInfo] { + return pulumix.Output[*NodeSystemInfo]{ + OutputState: o.OutputState, + } +} + func (o NodeSystemInfoPtrOutput) Elem() NodeSystemInfoOutput { return o.ApplyT(func(v *NodeSystemInfo) NodeSystemInfo { if v != nil { @@ -33380,6 +37953,12 @@ func (i NodeSystemInfoPatchArgs) ToNodeSystemInfoPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NodeSystemInfoPatchOutput) } +func (i NodeSystemInfoPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NodeSystemInfoPatch] { + return pulumix.Output[NodeSystemInfoPatch]{ + OutputState: i.ToNodeSystemInfoPatchOutputWithContext(ctx).OutputState, + } +} + func (i NodeSystemInfoPatchArgs) ToNodeSystemInfoPatchPtrOutput() NodeSystemInfoPatchPtrOutput { return i.ToNodeSystemInfoPatchPtrOutputWithContext(context.Background()) } @@ -33421,6 +38000,12 @@ func (i *nodeSystemInfoPatchPtrType) ToNodeSystemInfoPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(NodeSystemInfoPatchPtrOutput) } +func (i *nodeSystemInfoPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NodeSystemInfoPatch] { + return pulumix.Output[*NodeSystemInfoPatch]{ + OutputState: i.ToNodeSystemInfoPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NodeSystemInfo is a set of ids/uuids to uniquely identify the node. type NodeSystemInfoPatchOutput struct{ *pulumi.OutputState } @@ -33446,6 +38031,12 @@ func (o NodeSystemInfoPatchOutput) ToNodeSystemInfoPatchPtrOutputWithContext(ctx }).(NodeSystemInfoPatchPtrOutput) } +func (o NodeSystemInfoPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NodeSystemInfoPatch] { + return pulumix.Output[NodeSystemInfoPatch]{ + OutputState: o.OutputState, + } +} + // The Architecture reported by the node func (o NodeSystemInfoPatchOutput) Architecture() pulumi.StringPtrOutput { return o.ApplyT(func(v NodeSystemInfoPatch) *string { return v.Architecture }).(pulumi.StringPtrOutput) @@ -33510,6 +38101,12 @@ func (o NodeSystemInfoPatchPtrOutput) ToNodeSystemInfoPatchPtrOutputWithContext( return o } +func (o NodeSystemInfoPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NodeSystemInfoPatch] { + return pulumix.Output[*NodeSystemInfoPatch]{ + OutputState: o.OutputState, + } +} + func (o NodeSystemInfoPatchPtrOutput) Elem() NodeSystemInfoPatchOutput { return o.ApplyT(func(v *NodeSystemInfoPatch) NodeSystemInfoPatch { if v != nil { @@ -33659,6 +38256,12 @@ func (i ObjectFieldSelectorArgs) ToObjectFieldSelectorOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ObjectFieldSelectorOutput) } +func (i ObjectFieldSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectFieldSelector] { + return pulumix.Output[ObjectFieldSelector]{ + OutputState: i.ToObjectFieldSelectorOutputWithContext(ctx).OutputState, + } +} + func (i ObjectFieldSelectorArgs) ToObjectFieldSelectorPtrOutput() ObjectFieldSelectorPtrOutput { return i.ToObjectFieldSelectorPtrOutputWithContext(context.Background()) } @@ -33700,6 +38303,12 @@ func (i *objectFieldSelectorPtrType) ToObjectFieldSelectorPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ObjectFieldSelectorPtrOutput) } +func (i *objectFieldSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectFieldSelector] { + return pulumix.Output[*ObjectFieldSelector]{ + OutputState: i.ToObjectFieldSelectorPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectFieldSelector selects an APIVersioned field of an object. type ObjectFieldSelectorOutput struct{ *pulumi.OutputState } @@ -33725,6 +38334,12 @@ func (o ObjectFieldSelectorOutput) ToObjectFieldSelectorPtrOutputWithContext(ctx }).(ObjectFieldSelectorPtrOutput) } +func (o ObjectFieldSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectFieldSelector] { + return pulumix.Output[ObjectFieldSelector]{ + OutputState: o.OutputState, + } +} + // Version of the schema the FieldPath is written in terms of, defaults to "v1". func (o ObjectFieldSelectorOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectFieldSelector) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -33749,6 +38364,12 @@ func (o ObjectFieldSelectorPtrOutput) ToObjectFieldSelectorPtrOutputWithContext( return o } +func (o ObjectFieldSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectFieldSelector] { + return pulumix.Output[*ObjectFieldSelector]{ + OutputState: o.OutputState, + } +} + func (o ObjectFieldSelectorPtrOutput) Elem() ObjectFieldSelectorOutput { return o.ApplyT(func(v *ObjectFieldSelector) ObjectFieldSelector { if v != nil { @@ -33818,6 +38439,12 @@ func (i ObjectFieldSelectorPatchArgs) ToObjectFieldSelectorPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ObjectFieldSelectorPatchOutput) } +func (i ObjectFieldSelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectFieldSelectorPatch] { + return pulumix.Output[ObjectFieldSelectorPatch]{ + OutputState: i.ToObjectFieldSelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectFieldSelectorPatchArgs) ToObjectFieldSelectorPatchPtrOutput() ObjectFieldSelectorPatchPtrOutput { return i.ToObjectFieldSelectorPatchPtrOutputWithContext(context.Background()) } @@ -33859,6 +38486,12 @@ func (i *objectFieldSelectorPatchPtrType) ToObjectFieldSelectorPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ObjectFieldSelectorPatchPtrOutput) } +func (i *objectFieldSelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectFieldSelectorPatch] { + return pulumix.Output[*ObjectFieldSelectorPatch]{ + OutputState: i.ToObjectFieldSelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectFieldSelector selects an APIVersioned field of an object. type ObjectFieldSelectorPatchOutput struct{ *pulumi.OutputState } @@ -33884,6 +38517,12 @@ func (o ObjectFieldSelectorPatchOutput) ToObjectFieldSelectorPatchPtrOutputWithC }).(ObjectFieldSelectorPatchPtrOutput) } +func (o ObjectFieldSelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectFieldSelectorPatch] { + return pulumix.Output[ObjectFieldSelectorPatch]{ + OutputState: o.OutputState, + } +} + // Version of the schema the FieldPath is written in terms of, defaults to "v1". func (o ObjectFieldSelectorPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectFieldSelectorPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -33908,6 +38547,12 @@ func (o ObjectFieldSelectorPatchPtrOutput) ToObjectFieldSelectorPatchPtrOutputWi return o } +func (o ObjectFieldSelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectFieldSelectorPatch] { + return pulumix.Output[*ObjectFieldSelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectFieldSelectorPatchPtrOutput) Elem() ObjectFieldSelectorPatchOutput { return o.ApplyT(func(v *ObjectFieldSelectorPatch) ObjectFieldSelectorPatch { if v != nil { @@ -33997,6 +38642,12 @@ func (i ObjectReferenceArgs) ToObjectReferenceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ObjectReferenceOutput) } +func (i ObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectReference] { + return pulumix.Output[ObjectReference]{ + OutputState: i.ToObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ObjectReferenceArgs) ToObjectReferencePtrOutput() ObjectReferencePtrOutput { return i.ToObjectReferencePtrOutputWithContext(context.Background()) } @@ -34038,6 +38689,12 @@ func (i *objectReferencePtrType) ToObjectReferencePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(ObjectReferencePtrOutput) } +func (i *objectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectReference] { + return pulumix.Output[*ObjectReference]{ + OutputState: i.ToObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ObjectReferenceArrayInput is an input type that accepts ObjectReferenceArray and ObjectReferenceArrayOutput values. // You can construct a concrete instance of `ObjectReferenceArrayInput` via: // @@ -34063,6 +38720,12 @@ func (i ObjectReferenceArray) ToObjectReferenceArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ObjectReferenceArrayOutput) } +func (i ObjectReferenceArray) ToOutput(ctx context.Context) pulumix.Output[[]ObjectReference] { + return pulumix.Output[[]ObjectReference]{ + OutputState: i.ToObjectReferenceArrayOutputWithContext(ctx).OutputState, + } +} + // ObjectReference contains enough information to let you inspect or modify the referred object. type ObjectReferenceOutput struct{ *pulumi.OutputState } @@ -34088,6 +38751,12 @@ func (o ObjectReferenceOutput) ToObjectReferencePtrOutputWithContext(ctx context }).(ObjectReferencePtrOutput) } +func (o ObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectReference] { + return pulumix.Output[ObjectReference]{ + OutputState: o.OutputState, + } +} + // API version of the referent. func (o ObjectReferenceOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectReference) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -34137,6 +38806,12 @@ func (o ObjectReferencePtrOutput) ToObjectReferencePtrOutputWithContext(ctx cont return o } +func (o ObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectReference] { + return pulumix.Output[*ObjectReference]{ + OutputState: o.OutputState, + } +} + func (o ObjectReferencePtrOutput) Elem() ObjectReferenceOutput { return o.ApplyT(func(v *ObjectReference) ObjectReference { if v != nil { @@ -34231,6 +38906,12 @@ func (o ObjectReferenceArrayOutput) ToObjectReferenceArrayOutputWithContext(ctx return o } +func (o ObjectReferenceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ObjectReference] { + return pulumix.Output[[]ObjectReference]{ + OutputState: o.OutputState, + } +} + func (o ObjectReferenceArrayOutput) Index(i pulumi.IntInput) ObjectReferenceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObjectReference { return vs[0].([]ObjectReference)[vs[1].(int)] @@ -34296,6 +38977,12 @@ func (i ObjectReferencePatchArgs) ToObjectReferencePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ObjectReferencePatchOutput) } +func (i ObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectReferencePatch] { + return pulumix.Output[ObjectReferencePatch]{ + OutputState: i.ToObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectReferencePatchArgs) ToObjectReferencePatchPtrOutput() ObjectReferencePatchPtrOutput { return i.ToObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -34337,6 +39024,12 @@ func (i *objectReferencePatchPtrType) ToObjectReferencePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ObjectReferencePatchPtrOutput) } +func (i *objectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectReferencePatch] { + return pulumix.Output[*ObjectReferencePatch]{ + OutputState: i.ToObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectReferencePatchArrayInput is an input type that accepts ObjectReferencePatchArray and ObjectReferencePatchArrayOutput values. // You can construct a concrete instance of `ObjectReferencePatchArrayInput` via: // @@ -34362,6 +39055,12 @@ func (i ObjectReferencePatchArray) ToObjectReferencePatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ObjectReferencePatchArrayOutput) } +func (i ObjectReferencePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ObjectReferencePatch] { + return pulumix.Output[[]ObjectReferencePatch]{ + OutputState: i.ToObjectReferencePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ObjectReference contains enough information to let you inspect or modify the referred object. type ObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -34387,6 +39086,12 @@ func (o ObjectReferencePatchOutput) ToObjectReferencePatchPtrOutputWithContext(c }).(ObjectReferencePatchPtrOutput) } +func (o ObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectReferencePatch] { + return pulumix.Output[ObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // API version of the referent. func (o ObjectReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ObjectReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -34436,6 +39141,12 @@ func (o ObjectReferencePatchPtrOutput) ToObjectReferencePatchPtrOutputWithContex return o } +func (o ObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectReferencePatch] { + return pulumix.Output[*ObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectReferencePatchPtrOutput) Elem() ObjectReferencePatchOutput { return o.ApplyT(func(v *ObjectReferencePatch) ObjectReferencePatch { if v != nil { @@ -34530,6 +39241,12 @@ func (o ObjectReferencePatchArrayOutput) ToObjectReferencePatchArrayOutputWithCo return o } +func (o ObjectReferencePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ObjectReferencePatch] { + return pulumix.Output[[]ObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectReferencePatchArrayOutput) Index(i pulumi.IntInput) ObjectReferencePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObjectReferencePatch { return vs[0].([]ObjectReferencePatch)[vs[1].(int)] @@ -34587,6 +39304,12 @@ func (i PersistentVolumeTypeArgs) ToPersistentVolumeTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeTypeOutput) } +func (i PersistentVolumeTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeType] { + return pulumix.Output[PersistentVolumeType]{ + OutputState: i.ToPersistentVolumeTypeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeTypeArrayInput is an input type that accepts PersistentVolumeTypeArray and PersistentVolumeTypeArrayOutput values. // You can construct a concrete instance of `PersistentVolumeTypeArrayInput` via: // @@ -34612,6 +39335,12 @@ func (i PersistentVolumeTypeArray) ToPersistentVolumeTypeArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeTypeArrayOutput) } +func (i PersistentVolumeTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeType] { + return pulumix.Output[[]PersistentVolumeType]{ + OutputState: i.ToPersistentVolumeTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes type PersistentVolumeTypeOutput struct{ *pulumi.OutputState } @@ -34627,6 +39356,12 @@ func (o PersistentVolumeTypeOutput) ToPersistentVolumeTypeOutputWithContext(ctx return o } +func (o PersistentVolumeTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeType] { + return pulumix.Output[PersistentVolumeType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -34666,6 +39401,12 @@ func (o PersistentVolumeTypeArrayOutput) ToPersistentVolumeTypeArrayOutputWithCo return o } +func (o PersistentVolumeTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeType] { + return pulumix.Output[[]PersistentVolumeType]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeTypeArrayOutput) Index(i pulumi.IntInput) PersistentVolumeTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PersistentVolumeType { return vs[0].([]PersistentVolumeType)[vs[1].(int)] @@ -34723,6 +39464,12 @@ func (i PersistentVolumeClaimTypeArgs) ToPersistentVolumeClaimTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimTypeOutput) } +func (i PersistentVolumeClaimTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimType] { + return pulumix.Output[PersistentVolumeClaimType]{ + OutputState: i.ToPersistentVolumeClaimTypeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimTypeArrayInput is an input type that accepts PersistentVolumeClaimTypeArray and PersistentVolumeClaimTypeArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimTypeArrayInput` via: // @@ -34748,6 +39495,12 @@ func (i PersistentVolumeClaimTypeArray) ToPersistentVolumeClaimTypeArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimTypeArrayOutput) } +func (i PersistentVolumeClaimTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimType] { + return pulumix.Output[[]PersistentVolumeClaimType]{ + OutputState: i.ToPersistentVolumeClaimTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaim is a user's request for and claim to a persistent volume type PersistentVolumeClaimTypeOutput struct{ *pulumi.OutputState } @@ -34763,6 +39516,12 @@ func (o PersistentVolumeClaimTypeOutput) ToPersistentVolumeClaimTypeOutputWithCo return o } +func (o PersistentVolumeClaimTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimType] { + return pulumix.Output[PersistentVolumeClaimType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeClaimTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -34802,6 +39561,12 @@ func (o PersistentVolumeClaimTypeArrayOutput) ToPersistentVolumeClaimTypeArrayOu return o } +func (o PersistentVolumeClaimTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimType] { + return pulumix.Output[[]PersistentVolumeClaimType]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimTypeArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PersistentVolumeClaimType { return vs[0].([]PersistentVolumeClaimType)[vs[1].(int)] @@ -34859,6 +39624,12 @@ func (i PersistentVolumeClaimConditionArgs) ToPersistentVolumeClaimConditionOutp return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimConditionOutput) } +func (i PersistentVolumeClaimConditionArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimCondition] { + return pulumix.Output[PersistentVolumeClaimCondition]{ + OutputState: i.ToPersistentVolumeClaimConditionOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimConditionArrayInput is an input type that accepts PersistentVolumeClaimConditionArray and PersistentVolumeClaimConditionArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimConditionArrayInput` via: // @@ -34884,6 +39655,12 @@ func (i PersistentVolumeClaimConditionArray) ToPersistentVolumeClaimConditionArr return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimConditionArrayOutput) } +func (i PersistentVolumeClaimConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimCondition] { + return pulumix.Output[[]PersistentVolumeClaimCondition]{ + OutputState: i.ToPersistentVolumeClaimConditionArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimCondition contains details about state of pvc type PersistentVolumeClaimConditionOutput struct{ *pulumi.OutputState } @@ -34899,6 +39676,12 @@ func (o PersistentVolumeClaimConditionOutput) ToPersistentVolumeClaimConditionOu return o } +func (o PersistentVolumeClaimConditionOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimCondition] { + return pulumix.Output[PersistentVolumeClaimCondition]{ + OutputState: o.OutputState, + } +} + // lastProbeTime is the time we probed the condition. func (o PersistentVolumeClaimConditionOutput) LastProbeTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimCondition) *string { return v.LastProbeTime }).(pulumi.StringPtrOutput) @@ -34941,6 +39724,12 @@ func (o PersistentVolumeClaimConditionArrayOutput) ToPersistentVolumeClaimCondit return o } +func (o PersistentVolumeClaimConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimCondition] { + return pulumix.Output[[]PersistentVolumeClaimCondition]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimConditionArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PersistentVolumeClaimCondition { return vs[0].([]PersistentVolumeClaimCondition)[vs[1].(int)] @@ -34998,6 +39787,12 @@ func (i PersistentVolumeClaimConditionPatchArgs) ToPersistentVolumeClaimConditio return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimConditionPatchOutput) } +func (i PersistentVolumeClaimConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimConditionPatch] { + return pulumix.Output[PersistentVolumeClaimConditionPatch]{ + OutputState: i.ToPersistentVolumeClaimConditionPatchOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimConditionPatchArrayInput is an input type that accepts PersistentVolumeClaimConditionPatchArray and PersistentVolumeClaimConditionPatchArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimConditionPatchArrayInput` via: // @@ -35023,6 +39818,12 @@ func (i PersistentVolumeClaimConditionPatchArray) ToPersistentVolumeClaimConditi return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimConditionPatchArrayOutput) } +func (i PersistentVolumeClaimConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimConditionPatch] { + return pulumix.Output[[]PersistentVolumeClaimConditionPatch]{ + OutputState: i.ToPersistentVolumeClaimConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimCondition contains details about state of pvc type PersistentVolumeClaimConditionPatchOutput struct{ *pulumi.OutputState } @@ -35038,6 +39839,12 @@ func (o PersistentVolumeClaimConditionPatchOutput) ToPersistentVolumeClaimCondit return o } +func (o PersistentVolumeClaimConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimConditionPatch] { + return pulumix.Output[PersistentVolumeClaimConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastProbeTime is the time we probed the condition. func (o PersistentVolumeClaimConditionPatchOutput) LastProbeTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimConditionPatch) *string { return v.LastProbeTime }).(pulumi.StringPtrOutput) @@ -35080,6 +39887,12 @@ func (o PersistentVolumeClaimConditionPatchArrayOutput) ToPersistentVolumeClaimC return o } +func (o PersistentVolumeClaimConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimConditionPatch] { + return pulumix.Output[[]PersistentVolumeClaimConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimConditionPatchArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PersistentVolumeClaimConditionPatch { return vs[0].([]PersistentVolumeClaimConditionPatch)[vs[1].(int)] @@ -35133,6 +39946,12 @@ func (i PersistentVolumeClaimListTypeArgs) ToPersistentVolumeClaimListTypeOutput return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimListTypeOutput) } +func (i PersistentVolumeClaimListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimListType] { + return pulumix.Output[PersistentVolumeClaimListType]{ + OutputState: i.ToPersistentVolumeClaimListTypeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimList is a list of PersistentVolumeClaim items. type PersistentVolumeClaimListTypeOutput struct{ *pulumi.OutputState } @@ -35148,6 +39967,12 @@ func (o PersistentVolumeClaimListTypeOutput) ToPersistentVolumeClaimListTypeOutp return o } +func (o PersistentVolumeClaimListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimListType] { + return pulumix.Output[PersistentVolumeClaimListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeClaimListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -35219,6 +40044,12 @@ func (i PersistentVolumeClaimPatchTypeArgs) ToPersistentVolumeClaimPatchTypeOutp return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimPatchTypeOutput) } +func (i PersistentVolumeClaimPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimPatchType] { + return pulumix.Output[PersistentVolumeClaimPatchType]{ + OutputState: i.ToPersistentVolumeClaimPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimPatchTypeArrayInput is an input type that accepts PersistentVolumeClaimPatchTypeArray and PersistentVolumeClaimPatchTypeArrayOutput values. // You can construct a concrete instance of `PersistentVolumeClaimPatchTypeArrayInput` via: // @@ -35244,6 +40075,12 @@ func (i PersistentVolumeClaimPatchTypeArray) ToPersistentVolumeClaimPatchTypeArr return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimPatchTypeArrayOutput) } +func (i PersistentVolumeClaimPatchTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimPatchType] { + return pulumix.Output[[]PersistentVolumeClaimPatchType]{ + OutputState: i.ToPersistentVolumeClaimPatchTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaim is a user's request for and claim to a persistent volume type PersistentVolumeClaimPatchTypeOutput struct{ *pulumi.OutputState } @@ -35259,6 +40096,12 @@ func (o PersistentVolumeClaimPatchTypeOutput) ToPersistentVolumeClaimPatchTypeOu return o } +func (o PersistentVolumeClaimPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimPatchType] { + return pulumix.Output[PersistentVolumeClaimPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeClaimPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -35298,6 +40141,12 @@ func (o PersistentVolumeClaimPatchTypeArrayOutput) ToPersistentVolumeClaimPatchT return o } +func (o PersistentVolumeClaimPatchTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PersistentVolumeClaimPatchType] { + return pulumix.Output[[]PersistentVolumeClaimPatchType]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimPatchTypeArrayOutput) Index(i pulumi.IntInput) PersistentVolumeClaimPatchTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PersistentVolumeClaimPatchType { return vs[0].([]PersistentVolumeClaimPatchType)[vs[1].(int)] @@ -35381,6 +40230,12 @@ func (i PersistentVolumeClaimSpecArgs) ToPersistentVolumeClaimSpecOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimSpecOutput) } +func (i PersistentVolumeClaimSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimSpec] { + return pulumix.Output[PersistentVolumeClaimSpec]{ + OutputState: i.ToPersistentVolumeClaimSpecOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimSpecArgs) ToPersistentVolumeClaimSpecPtrOutput() PersistentVolumeClaimSpecPtrOutput { return i.ToPersistentVolumeClaimSpecPtrOutputWithContext(context.Background()) } @@ -35422,6 +40277,12 @@ func (i *persistentVolumeClaimSpecPtrType) ToPersistentVolumeClaimSpecPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimSpecPtrOutput) } +func (i *persistentVolumeClaimSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimSpec] { + return pulumix.Output[*PersistentVolumeClaimSpec]{ + OutputState: i.ToPersistentVolumeClaimSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes type PersistentVolumeClaimSpecOutput struct{ *pulumi.OutputState } @@ -35447,6 +40308,12 @@ func (o PersistentVolumeClaimSpecOutput) ToPersistentVolumeClaimSpecPtrOutputWit }).(PersistentVolumeClaimSpecPtrOutput) } +func (o PersistentVolumeClaimSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimSpec] { + return pulumix.Output[PersistentVolumeClaimSpec]{ + OutputState: o.OutputState, + } +} + // accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 func (o PersistentVolumeClaimSpecOutput) AccessModes() pulumi.StringArrayOutput { return o.ApplyT(func(v PersistentVolumeClaimSpec) []string { return v.AccessModes }).(pulumi.StringArrayOutput) @@ -35509,6 +40376,12 @@ func (o PersistentVolumeClaimSpecPtrOutput) ToPersistentVolumeClaimSpecPtrOutput return o } +func (o PersistentVolumeClaimSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimSpec] { + return pulumix.Output[*PersistentVolumeClaimSpec]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimSpecPtrOutput) Elem() PersistentVolumeClaimSpecOutput { return o.ApplyT(func(v *PersistentVolumeClaimSpec) PersistentVolumeClaimSpec { if v != nil { @@ -35684,6 +40557,12 @@ func (i PersistentVolumeClaimSpecPatchArgs) ToPersistentVolumeClaimSpecPatchOutp return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimSpecPatchOutput) } +func (i PersistentVolumeClaimSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimSpecPatch] { + return pulumix.Output[PersistentVolumeClaimSpecPatch]{ + OutputState: i.ToPersistentVolumeClaimSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimSpecPatchArgs) ToPersistentVolumeClaimSpecPatchPtrOutput() PersistentVolumeClaimSpecPatchPtrOutput { return i.ToPersistentVolumeClaimSpecPatchPtrOutputWithContext(context.Background()) } @@ -35725,6 +40604,12 @@ func (i *persistentVolumeClaimSpecPatchPtrType) ToPersistentVolumeClaimSpecPatch return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimSpecPatchPtrOutput) } +func (i *persistentVolumeClaimSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimSpecPatch] { + return pulumix.Output[*PersistentVolumeClaimSpecPatch]{ + OutputState: i.ToPersistentVolumeClaimSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes type PersistentVolumeClaimSpecPatchOutput struct{ *pulumi.OutputState } @@ -35750,6 +40635,12 @@ func (o PersistentVolumeClaimSpecPatchOutput) ToPersistentVolumeClaimSpecPatchPt }).(PersistentVolumeClaimSpecPatchPtrOutput) } +func (o PersistentVolumeClaimSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimSpecPatch] { + return pulumix.Output[PersistentVolumeClaimSpecPatch]{ + OutputState: o.OutputState, + } +} + // accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 func (o PersistentVolumeClaimSpecPatchOutput) AccessModes() pulumi.StringArrayOutput { return o.ApplyT(func(v PersistentVolumeClaimSpecPatch) []string { return v.AccessModes }).(pulumi.StringArrayOutput) @@ -35812,6 +40703,12 @@ func (o PersistentVolumeClaimSpecPatchPtrOutput) ToPersistentVolumeClaimSpecPatc return o } +func (o PersistentVolumeClaimSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimSpecPatch] { + return pulumix.Output[*PersistentVolumeClaimSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimSpecPatchPtrOutput) Elem() PersistentVolumeClaimSpecPatchOutput { return o.ApplyT(func(v *PersistentVolumeClaimSpecPatch) PersistentVolumeClaimSpecPatch { if v != nil { @@ -36047,6 +40944,12 @@ func (i PersistentVolumeClaimStatusArgs) ToPersistentVolumeClaimStatusOutputWith return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimStatusOutput) } +func (i PersistentVolumeClaimStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimStatus] { + return pulumix.Output[PersistentVolumeClaimStatus]{ + OutputState: i.ToPersistentVolumeClaimStatusOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimStatusArgs) ToPersistentVolumeClaimStatusPtrOutput() PersistentVolumeClaimStatusPtrOutput { return i.ToPersistentVolumeClaimStatusPtrOutputWithContext(context.Background()) } @@ -36088,6 +40991,12 @@ func (i *persistentVolumeClaimStatusPtrType) ToPersistentVolumeClaimStatusPtrOut return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimStatusPtrOutput) } +func (i *persistentVolumeClaimStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimStatus] { + return pulumix.Output[*PersistentVolumeClaimStatus]{ + OutputState: i.ToPersistentVolumeClaimStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimStatus is the current status of a persistent volume claim. type PersistentVolumeClaimStatusOutput struct{ *pulumi.OutputState } @@ -36113,6 +41022,12 @@ func (o PersistentVolumeClaimStatusOutput) ToPersistentVolumeClaimStatusPtrOutpu }).(PersistentVolumeClaimStatusPtrOutput) } +func (o PersistentVolumeClaimStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimStatus] { + return pulumix.Output[PersistentVolumeClaimStatus]{ + OutputState: o.OutputState, + } +} + // accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 func (o PersistentVolumeClaimStatusOutput) AccessModes() pulumi.StringArrayOutput { return o.ApplyT(func(v PersistentVolumeClaimStatus) []string { return v.AccessModes }).(pulumi.StringArrayOutput) @@ -36205,6 +41120,12 @@ func (o PersistentVolumeClaimStatusPtrOutput) ToPersistentVolumeClaimStatusPtrOu return o } +func (o PersistentVolumeClaimStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimStatus] { + return pulumix.Output[*PersistentVolumeClaimStatus]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimStatusPtrOutput) Elem() PersistentVolumeClaimStatusOutput { return o.ApplyT(func(v *PersistentVolumeClaimStatus) PersistentVolumeClaimStatus { if v != nil { @@ -36465,6 +41386,12 @@ func (i PersistentVolumeClaimStatusPatchArgs) ToPersistentVolumeClaimStatusPatch return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimStatusPatchOutput) } +func (i PersistentVolumeClaimStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimStatusPatch] { + return pulumix.Output[PersistentVolumeClaimStatusPatch]{ + OutputState: i.ToPersistentVolumeClaimStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimStatusPatchArgs) ToPersistentVolumeClaimStatusPatchPtrOutput() PersistentVolumeClaimStatusPatchPtrOutput { return i.ToPersistentVolumeClaimStatusPatchPtrOutputWithContext(context.Background()) } @@ -36506,6 +41433,12 @@ func (i *persistentVolumeClaimStatusPatchPtrType) ToPersistentVolumeClaimStatusP return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimStatusPatchPtrOutput) } +func (i *persistentVolumeClaimStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimStatusPatch] { + return pulumix.Output[*PersistentVolumeClaimStatusPatch]{ + OutputState: i.ToPersistentVolumeClaimStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimStatus is the current status of a persistent volume claim. type PersistentVolumeClaimStatusPatchOutput struct{ *pulumi.OutputState } @@ -36531,6 +41464,12 @@ func (o PersistentVolumeClaimStatusPatchOutput) ToPersistentVolumeClaimStatusPat }).(PersistentVolumeClaimStatusPatchPtrOutput) } +func (o PersistentVolumeClaimStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimStatusPatch] { + return pulumix.Output[PersistentVolumeClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + // accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 func (o PersistentVolumeClaimStatusPatchOutput) AccessModes() pulumi.StringArrayOutput { return o.ApplyT(func(v PersistentVolumeClaimStatusPatch) []string { return v.AccessModes }).(pulumi.StringArrayOutput) @@ -36623,6 +41562,12 @@ func (o PersistentVolumeClaimStatusPatchPtrOutput) ToPersistentVolumeClaimStatus return o } +func (o PersistentVolumeClaimStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimStatusPatch] { + return pulumix.Output[*PersistentVolumeClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimStatusPatchPtrOutput) Elem() PersistentVolumeClaimStatusPatchOutput { return o.ApplyT(func(v *PersistentVolumeClaimStatusPatch) PersistentVolumeClaimStatusPatch { if v != nil { @@ -36785,6 +41730,12 @@ func (i PersistentVolumeClaimTemplateArgs) ToPersistentVolumeClaimTemplateOutput return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimTemplateOutput) } +func (i PersistentVolumeClaimTemplateArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimTemplate] { + return pulumix.Output[PersistentVolumeClaimTemplate]{ + OutputState: i.ToPersistentVolumeClaimTemplateOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimTemplateArgs) ToPersistentVolumeClaimTemplatePtrOutput() PersistentVolumeClaimTemplatePtrOutput { return i.ToPersistentVolumeClaimTemplatePtrOutputWithContext(context.Background()) } @@ -36826,6 +41777,12 @@ func (i *persistentVolumeClaimTemplatePtrType) ToPersistentVolumeClaimTemplatePt return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimTemplatePtrOutput) } +func (i *persistentVolumeClaimTemplatePtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimTemplate] { + return pulumix.Output[*PersistentVolumeClaimTemplate]{ + OutputState: i.ToPersistentVolumeClaimTemplatePtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource. type PersistentVolumeClaimTemplateOutput struct{ *pulumi.OutputState } @@ -36851,6 +41808,12 @@ func (o PersistentVolumeClaimTemplateOutput) ToPersistentVolumeClaimTemplatePtrO }).(PersistentVolumeClaimTemplatePtrOutput) } +func (o PersistentVolumeClaimTemplateOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimTemplate] { + return pulumix.Output[PersistentVolumeClaimTemplate]{ + OutputState: o.OutputState, + } +} + // May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. func (o PersistentVolumeClaimTemplateOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimTemplate) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -36875,6 +41838,12 @@ func (o PersistentVolumeClaimTemplatePtrOutput) ToPersistentVolumeClaimTemplateP return o } +func (o PersistentVolumeClaimTemplatePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimTemplate] { + return pulumix.Output[*PersistentVolumeClaimTemplate]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimTemplatePtrOutput) Elem() PersistentVolumeClaimTemplateOutput { return o.ApplyT(func(v *PersistentVolumeClaimTemplate) PersistentVolumeClaimTemplate { if v != nil { @@ -36944,6 +41913,12 @@ func (i PersistentVolumeClaimTemplatePatchArgs) ToPersistentVolumeClaimTemplateP return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimTemplatePatchOutput) } +func (i PersistentVolumeClaimTemplatePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimTemplatePatch] { + return pulumix.Output[PersistentVolumeClaimTemplatePatch]{ + OutputState: i.ToPersistentVolumeClaimTemplatePatchOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimTemplatePatchArgs) ToPersistentVolumeClaimTemplatePatchPtrOutput() PersistentVolumeClaimTemplatePatchPtrOutput { return i.ToPersistentVolumeClaimTemplatePatchPtrOutputWithContext(context.Background()) } @@ -36985,6 +41960,12 @@ func (i *persistentVolumeClaimTemplatePatchPtrType) ToPersistentVolumeClaimTempl return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimTemplatePatchPtrOutput) } +func (i *persistentVolumeClaimTemplatePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimTemplatePatch] { + return pulumix.Output[*PersistentVolumeClaimTemplatePatch]{ + OutputState: i.ToPersistentVolumeClaimTemplatePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource. type PersistentVolumeClaimTemplatePatchOutput struct{ *pulumi.OutputState } @@ -37010,6 +41991,12 @@ func (o PersistentVolumeClaimTemplatePatchOutput) ToPersistentVolumeClaimTemplat }).(PersistentVolumeClaimTemplatePatchPtrOutput) } +func (o PersistentVolumeClaimTemplatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimTemplatePatch] { + return pulumix.Output[PersistentVolumeClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + // May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. func (o PersistentVolumeClaimTemplatePatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimTemplatePatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -37034,6 +42021,12 @@ func (o PersistentVolumeClaimTemplatePatchPtrOutput) ToPersistentVolumeClaimTemp return o } +func (o PersistentVolumeClaimTemplatePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimTemplatePatch] { + return pulumix.Output[*PersistentVolumeClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimTemplatePatchPtrOutput) Elem() PersistentVolumeClaimTemplatePatchOutput { return o.ApplyT(func(v *PersistentVolumeClaimTemplatePatch) PersistentVolumeClaimTemplatePatch { if v != nil { @@ -37103,6 +42096,12 @@ func (i PersistentVolumeClaimVolumeSourceArgs) ToPersistentVolumeClaimVolumeSour return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimVolumeSourceOutput) } +func (i PersistentVolumeClaimVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimVolumeSource] { + return pulumix.Output[PersistentVolumeClaimVolumeSource]{ + OutputState: i.ToPersistentVolumeClaimVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimVolumeSourceArgs) ToPersistentVolumeClaimVolumeSourcePtrOutput() PersistentVolumeClaimVolumeSourcePtrOutput { return i.ToPersistentVolumeClaimVolumeSourcePtrOutputWithContext(context.Background()) } @@ -37144,6 +42143,12 @@ func (i *persistentVolumeClaimVolumeSourcePtrType) ToPersistentVolumeClaimVolume return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimVolumeSourcePtrOutput) } +func (i *persistentVolumeClaimVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimVolumeSource] { + return pulumix.Output[*PersistentVolumeClaimVolumeSource]{ + OutputState: i.ToPersistentVolumeClaimVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system). type PersistentVolumeClaimVolumeSourceOutput struct{ *pulumi.OutputState } @@ -37169,6 +42174,12 @@ func (o PersistentVolumeClaimVolumeSourceOutput) ToPersistentVolumeClaimVolumeSo }).(PersistentVolumeClaimVolumeSourcePtrOutput) } +func (o PersistentVolumeClaimVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimVolumeSource] { + return pulumix.Output[PersistentVolumeClaimVolumeSource]{ + OutputState: o.OutputState, + } +} + // claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims func (o PersistentVolumeClaimVolumeSourceOutput) ClaimName() pulumi.StringOutput { return o.ApplyT(func(v PersistentVolumeClaimVolumeSource) string { return v.ClaimName }).(pulumi.StringOutput) @@ -37193,6 +42204,12 @@ func (o PersistentVolumeClaimVolumeSourcePtrOutput) ToPersistentVolumeClaimVolum return o } +func (o PersistentVolumeClaimVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimVolumeSource] { + return pulumix.Output[*PersistentVolumeClaimVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimVolumeSourcePtrOutput) Elem() PersistentVolumeClaimVolumeSourceOutput { return o.ApplyT(func(v *PersistentVolumeClaimVolumeSource) PersistentVolumeClaimVolumeSource { if v != nil { @@ -37262,6 +42279,12 @@ func (i PersistentVolumeClaimVolumeSourcePatchArgs) ToPersistentVolumeClaimVolum return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimVolumeSourcePatchOutput) } +func (i PersistentVolumeClaimVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimVolumeSourcePatch] { + return pulumix.Output[PersistentVolumeClaimVolumeSourcePatch]{ + OutputState: i.ToPersistentVolumeClaimVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeClaimVolumeSourcePatchArgs) ToPersistentVolumeClaimVolumeSourcePatchPtrOutput() PersistentVolumeClaimVolumeSourcePatchPtrOutput { return i.ToPersistentVolumeClaimVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -37303,6 +42326,12 @@ func (i *persistentVolumeClaimVolumeSourcePatchPtrType) ToPersistentVolumeClaimV return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeClaimVolumeSourcePatchPtrOutput) } +func (i *persistentVolumeClaimVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimVolumeSourcePatch] { + return pulumix.Output[*PersistentVolumeClaimVolumeSourcePatch]{ + OutputState: i.ToPersistentVolumeClaimVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system). type PersistentVolumeClaimVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -37328,6 +42357,12 @@ func (o PersistentVolumeClaimVolumeSourcePatchOutput) ToPersistentVolumeClaimVol }).(PersistentVolumeClaimVolumeSourcePatchPtrOutput) } +func (o PersistentVolumeClaimVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeClaimVolumeSourcePatch] { + return pulumix.Output[PersistentVolumeClaimVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims func (o PersistentVolumeClaimVolumeSourcePatchOutput) ClaimName() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeClaimVolumeSourcePatch) *string { return v.ClaimName }).(pulumi.StringPtrOutput) @@ -37352,6 +42387,12 @@ func (o PersistentVolumeClaimVolumeSourcePatchPtrOutput) ToPersistentVolumeClaim return o } +func (o PersistentVolumeClaimVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeClaimVolumeSourcePatch] { + return pulumix.Output[*PersistentVolumeClaimVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeClaimVolumeSourcePatchPtrOutput) Elem() PersistentVolumeClaimVolumeSourcePatchOutput { return o.ApplyT(func(v *PersistentVolumeClaimVolumeSourcePatch) PersistentVolumeClaimVolumeSourcePatch { if v != nil { @@ -37429,6 +42470,12 @@ func (i PersistentVolumeListTypeArgs) ToPersistentVolumeListTypeOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeListTypeOutput) } +func (i PersistentVolumeListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeListType] { + return pulumix.Output[PersistentVolumeListType]{ + OutputState: i.ToPersistentVolumeListTypeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeList is a list of PersistentVolume items. type PersistentVolumeListTypeOutput struct{ *pulumi.OutputState } @@ -37444,6 +42491,12 @@ func (o PersistentVolumeListTypeOutput) ToPersistentVolumeListTypeOutputWithCont return o } +func (o PersistentVolumeListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeListType] { + return pulumix.Output[PersistentVolumeListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumeListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -37515,6 +42568,12 @@ func (i PersistentVolumePatchTypeArgs) ToPersistentVolumePatchTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumePatchTypeOutput) } +func (i PersistentVolumePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumePatchType] { + return pulumix.Output[PersistentVolumePatchType]{ + OutputState: i.ToPersistentVolumePatchTypeOutputWithContext(ctx).OutputState, + } +} + // PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes type PersistentVolumePatchTypeOutput struct{ *pulumi.OutputState } @@ -37530,6 +42589,12 @@ func (o PersistentVolumePatchTypeOutput) ToPersistentVolumePatchTypeOutputWithCo return o } +func (o PersistentVolumePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumePatchType] { + return pulumix.Output[PersistentVolumePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PersistentVolumePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -37706,6 +42771,12 @@ func (i PersistentVolumeSpecArgs) ToPersistentVolumeSpecOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeSpecOutput) } +func (i PersistentVolumeSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeSpec] { + return pulumix.Output[PersistentVolumeSpec]{ + OutputState: i.ToPersistentVolumeSpecOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeSpecArgs) ToPersistentVolumeSpecPtrOutput() PersistentVolumeSpecPtrOutput { return i.ToPersistentVolumeSpecPtrOutputWithContext(context.Background()) } @@ -37747,6 +42818,12 @@ func (i *persistentVolumeSpecPtrType) ToPersistentVolumeSpecPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeSpecPtrOutput) } +func (i *persistentVolumeSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeSpec] { + return pulumix.Output[*PersistentVolumeSpec]{ + OutputState: i.ToPersistentVolumeSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeSpec is the specification of a persistent volume. type PersistentVolumeSpecOutput struct{ *pulumi.OutputState } @@ -37772,6 +42849,12 @@ func (o PersistentVolumeSpecOutput) ToPersistentVolumeSpecPtrOutputWithContext(c }).(PersistentVolumeSpecPtrOutput) } +func (o PersistentVolumeSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeSpec] { + return pulumix.Output[PersistentVolumeSpec]{ + OutputState: o.OutputState, + } +} + // accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes func (o PersistentVolumeSpecOutput) AccessModes() pulumi.StringArrayOutput { return o.ApplyT(func(v PersistentVolumeSpec) []string { return v.AccessModes }).(pulumi.StringArrayOutput) @@ -37936,6 +43019,12 @@ func (o PersistentVolumeSpecPtrOutput) ToPersistentVolumeSpecPtrOutputWithContex return o } +func (o PersistentVolumeSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeSpec] { + return pulumix.Output[*PersistentVolumeSpec]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeSpecPtrOutput) Elem() PersistentVolumeSpecOutput { return o.ApplyT(func(v *PersistentVolumeSpec) PersistentVolumeSpec { if v != nil { @@ -38397,6 +43486,12 @@ func (i PersistentVolumeSpecPatchArgs) ToPersistentVolumeSpecPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeSpecPatchOutput) } +func (i PersistentVolumeSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeSpecPatch] { + return pulumix.Output[PersistentVolumeSpecPatch]{ + OutputState: i.ToPersistentVolumeSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeSpecPatchArgs) ToPersistentVolumeSpecPatchPtrOutput() PersistentVolumeSpecPatchPtrOutput { return i.ToPersistentVolumeSpecPatchPtrOutputWithContext(context.Background()) } @@ -38438,6 +43533,12 @@ func (i *persistentVolumeSpecPatchPtrType) ToPersistentVolumeSpecPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeSpecPatchPtrOutput) } +func (i *persistentVolumeSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeSpecPatch] { + return pulumix.Output[*PersistentVolumeSpecPatch]{ + OutputState: i.ToPersistentVolumeSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeSpec is the specification of a persistent volume. type PersistentVolumeSpecPatchOutput struct{ *pulumi.OutputState } @@ -38463,6 +43564,12 @@ func (o PersistentVolumeSpecPatchOutput) ToPersistentVolumeSpecPatchPtrOutputWit }).(PersistentVolumeSpecPatchPtrOutput) } +func (o PersistentVolumeSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeSpecPatch] { + return pulumix.Output[PersistentVolumeSpecPatch]{ + OutputState: o.OutputState, + } +} + // accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes func (o PersistentVolumeSpecPatchOutput) AccessModes() pulumi.StringArrayOutput { return o.ApplyT(func(v PersistentVolumeSpecPatch) []string { return v.AccessModes }).(pulumi.StringArrayOutput) @@ -38631,6 +43738,12 @@ func (o PersistentVolumeSpecPatchPtrOutput) ToPersistentVolumeSpecPatchPtrOutput return o } +func (o PersistentVolumeSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeSpecPatch] { + return pulumix.Output[*PersistentVolumeSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeSpecPatchPtrOutput) Elem() PersistentVolumeSpecPatchOutput { return o.ApplyT(func(v *PersistentVolumeSpecPatch) PersistentVolumeSpecPatch { if v != nil { @@ -38988,6 +44101,12 @@ func (i PersistentVolumeStatusArgs) ToPersistentVolumeStatusOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeStatusOutput) } +func (i PersistentVolumeStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeStatus] { + return pulumix.Output[PersistentVolumeStatus]{ + OutputState: i.ToPersistentVolumeStatusOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeStatusArgs) ToPersistentVolumeStatusPtrOutput() PersistentVolumeStatusPtrOutput { return i.ToPersistentVolumeStatusPtrOutputWithContext(context.Background()) } @@ -39029,6 +44148,12 @@ func (i *persistentVolumeStatusPtrType) ToPersistentVolumeStatusPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeStatusPtrOutput) } +func (i *persistentVolumeStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeStatus] { + return pulumix.Output[*PersistentVolumeStatus]{ + OutputState: i.ToPersistentVolumeStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeStatus is the current status of a persistent volume. type PersistentVolumeStatusOutput struct{ *pulumi.OutputState } @@ -39054,6 +44179,12 @@ func (o PersistentVolumeStatusOutput) ToPersistentVolumeStatusPtrOutputWithConte }).(PersistentVolumeStatusPtrOutput) } +func (o PersistentVolumeStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeStatus] { + return pulumix.Output[PersistentVolumeStatus]{ + OutputState: o.OutputState, + } +} + // lastPhaseTransitionTime is the time the phase transitioned from one to another and automatically resets to current time everytime a volume phase transitions. This is an alpha field and requires enabling PersistentVolumeLastPhaseTransitionTime feature. func (o PersistentVolumeStatusOutput) LastPhaseTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeStatus) *string { return v.LastPhaseTransitionTime }).(pulumi.StringPtrOutput) @@ -39088,6 +44219,12 @@ func (o PersistentVolumeStatusPtrOutput) ToPersistentVolumeStatusPtrOutputWithCo return o } +func (o PersistentVolumeStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeStatus] { + return pulumix.Output[*PersistentVolumeStatus]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeStatusPtrOutput) Elem() PersistentVolumeStatusOutput { return o.ApplyT(func(v *PersistentVolumeStatus) PersistentVolumeStatus { if v != nil { @@ -39185,6 +44322,12 @@ func (i PersistentVolumeStatusPatchArgs) ToPersistentVolumeStatusPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeStatusPatchOutput) } +func (i PersistentVolumeStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeStatusPatch] { + return pulumix.Output[PersistentVolumeStatusPatch]{ + OutputState: i.ToPersistentVolumeStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PersistentVolumeStatusPatchArgs) ToPersistentVolumeStatusPatchPtrOutput() PersistentVolumeStatusPatchPtrOutput { return i.ToPersistentVolumeStatusPatchPtrOutputWithContext(context.Background()) } @@ -39226,6 +44369,12 @@ func (i *persistentVolumeStatusPatchPtrType) ToPersistentVolumeStatusPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(PersistentVolumeStatusPatchPtrOutput) } +func (i *persistentVolumeStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeStatusPatch] { + return pulumix.Output[*PersistentVolumeStatusPatch]{ + OutputState: i.ToPersistentVolumeStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PersistentVolumeStatus is the current status of a persistent volume. type PersistentVolumeStatusPatchOutput struct{ *pulumi.OutputState } @@ -39251,6 +44400,12 @@ func (o PersistentVolumeStatusPatchOutput) ToPersistentVolumeStatusPatchPtrOutpu }).(PersistentVolumeStatusPatchPtrOutput) } +func (o PersistentVolumeStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PersistentVolumeStatusPatch] { + return pulumix.Output[PersistentVolumeStatusPatch]{ + OutputState: o.OutputState, + } +} + // lastPhaseTransitionTime is the time the phase transitioned from one to another and automatically resets to current time everytime a volume phase transitions. This is an alpha field and requires enabling PersistentVolumeLastPhaseTransitionTime feature. func (o PersistentVolumeStatusPatchOutput) LastPhaseTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PersistentVolumeStatusPatch) *string { return v.LastPhaseTransitionTime }).(pulumi.StringPtrOutput) @@ -39285,6 +44440,12 @@ func (o PersistentVolumeStatusPatchPtrOutput) ToPersistentVolumeStatusPatchPtrOu return o } +func (o PersistentVolumeStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PersistentVolumeStatusPatch] { + return pulumix.Output[*PersistentVolumeStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PersistentVolumeStatusPatchPtrOutput) Elem() PersistentVolumeStatusPatchOutput { return o.ApplyT(func(v *PersistentVolumeStatusPatch) PersistentVolumeStatusPatch { if v != nil { @@ -39374,6 +44535,12 @@ func (i PhotonPersistentDiskVolumeSourceArgs) ToPhotonPersistentDiskVolumeSource return pulumi.ToOutputWithContext(ctx, i).(PhotonPersistentDiskVolumeSourceOutput) } +func (i PhotonPersistentDiskVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[PhotonPersistentDiskVolumeSource] { + return pulumix.Output[PhotonPersistentDiskVolumeSource]{ + OutputState: i.ToPhotonPersistentDiskVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i PhotonPersistentDiskVolumeSourceArgs) ToPhotonPersistentDiskVolumeSourcePtrOutput() PhotonPersistentDiskVolumeSourcePtrOutput { return i.ToPhotonPersistentDiskVolumeSourcePtrOutputWithContext(context.Background()) } @@ -39415,6 +44582,12 @@ func (i *photonPersistentDiskVolumeSourcePtrType) ToPhotonPersistentDiskVolumeSo return pulumi.ToOutputWithContext(ctx, i).(PhotonPersistentDiskVolumeSourcePtrOutput) } +func (i *photonPersistentDiskVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*PhotonPersistentDiskVolumeSource] { + return pulumix.Output[*PhotonPersistentDiskVolumeSource]{ + OutputState: i.ToPhotonPersistentDiskVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Photon Controller persistent disk resource. type PhotonPersistentDiskVolumeSourceOutput struct{ *pulumi.OutputState } @@ -39440,6 +44613,12 @@ func (o PhotonPersistentDiskVolumeSourceOutput) ToPhotonPersistentDiskVolumeSour }).(PhotonPersistentDiskVolumeSourcePtrOutput) } +func (o PhotonPersistentDiskVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[PhotonPersistentDiskVolumeSource] { + return pulumix.Output[PhotonPersistentDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o PhotonPersistentDiskVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v PhotonPersistentDiskVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -39464,6 +44643,12 @@ func (o PhotonPersistentDiskVolumeSourcePtrOutput) ToPhotonPersistentDiskVolumeS return o } +func (o PhotonPersistentDiskVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PhotonPersistentDiskVolumeSource] { + return pulumix.Output[*PhotonPersistentDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o PhotonPersistentDiskVolumeSourcePtrOutput) Elem() PhotonPersistentDiskVolumeSourceOutput { return o.ApplyT(func(v *PhotonPersistentDiskVolumeSource) PhotonPersistentDiskVolumeSource { if v != nil { @@ -39533,6 +44718,12 @@ func (i PhotonPersistentDiskVolumeSourcePatchArgs) ToPhotonPersistentDiskVolumeS return pulumi.ToOutputWithContext(ctx, i).(PhotonPersistentDiskVolumeSourcePatchOutput) } +func (i PhotonPersistentDiskVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PhotonPersistentDiskVolumeSourcePatch] { + return pulumix.Output[PhotonPersistentDiskVolumeSourcePatch]{ + OutputState: i.ToPhotonPersistentDiskVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i PhotonPersistentDiskVolumeSourcePatchArgs) ToPhotonPersistentDiskVolumeSourcePatchPtrOutput() PhotonPersistentDiskVolumeSourcePatchPtrOutput { return i.ToPhotonPersistentDiskVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -39574,6 +44765,12 @@ func (i *photonPersistentDiskVolumeSourcePatchPtrType) ToPhotonPersistentDiskVol return pulumi.ToOutputWithContext(ctx, i).(PhotonPersistentDiskVolumeSourcePatchPtrOutput) } +func (i *photonPersistentDiskVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PhotonPersistentDiskVolumeSourcePatch] { + return pulumix.Output[*PhotonPersistentDiskVolumeSourcePatch]{ + OutputState: i.ToPhotonPersistentDiskVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Photon Controller persistent disk resource. type PhotonPersistentDiskVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -39599,6 +44796,12 @@ func (o PhotonPersistentDiskVolumeSourcePatchOutput) ToPhotonPersistentDiskVolum }).(PhotonPersistentDiskVolumeSourcePatchPtrOutput) } +func (o PhotonPersistentDiskVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PhotonPersistentDiskVolumeSourcePatch] { + return pulumix.Output[PhotonPersistentDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o PhotonPersistentDiskVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v PhotonPersistentDiskVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -39623,6 +44826,12 @@ func (o PhotonPersistentDiskVolumeSourcePatchPtrOutput) ToPhotonPersistentDiskVo return o } +func (o PhotonPersistentDiskVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PhotonPersistentDiskVolumeSourcePatch] { + return pulumix.Output[*PhotonPersistentDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o PhotonPersistentDiskVolumeSourcePatchPtrOutput) Elem() PhotonPersistentDiskVolumeSourcePatchOutput { return o.ApplyT(func(v *PhotonPersistentDiskVolumeSourcePatch) PhotonPersistentDiskVolumeSourcePatch { if v != nil { @@ -39734,6 +44943,12 @@ func (i PodTypeArgs) ToPodTypeOutputWithContext(ctx context.Context) PodTypeOutp return pulumi.ToOutputWithContext(ctx, i).(PodTypeOutput) } +func (i PodTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodType] { + return pulumix.Output[PodType]{ + OutputState: i.ToPodTypeOutputWithContext(ctx).OutputState, + } +} + // PodTypeArrayInput is an input type that accepts PodTypeArray and PodTypeArrayOutput values. // You can construct a concrete instance of `PodTypeArrayInput` via: // @@ -39759,6 +44974,12 @@ func (i PodTypeArray) ToPodTypeArrayOutputWithContext(ctx context.Context) PodTy return pulumi.ToOutputWithContext(ctx, i).(PodTypeArrayOutput) } +func (i PodTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodType] { + return pulumix.Output[[]PodType]{ + OutputState: i.ToPodTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts. // // This resource waits until its status is ready before registering success @@ -39789,6 +45010,12 @@ func (o PodTypeOutput) ToPodTypeOutputWithContext(ctx context.Context) PodTypeOu return o } +func (o PodTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodType] { + return pulumix.Output[PodType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -39828,6 +45055,12 @@ func (o PodTypeArrayOutput) ToPodTypeArrayOutputWithContext(ctx context.Context) return o } +func (o PodTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodType] { + return pulumix.Output[[]PodType]{ + OutputState: o.OutputState, + } +} + func (o PodTypeArrayOutput) Index(i pulumi.IntInput) PodTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodType { return vs[0].([]PodType)[vs[1].(int)] @@ -39873,6 +45106,12 @@ func (i PodAffinityArgs) ToPodAffinityOutputWithContext(ctx context.Context) Pod return pulumi.ToOutputWithContext(ctx, i).(PodAffinityOutput) } +func (i PodAffinityArgs) ToOutput(ctx context.Context) pulumix.Output[PodAffinity] { + return pulumix.Output[PodAffinity]{ + OutputState: i.ToPodAffinityOutputWithContext(ctx).OutputState, + } +} + func (i PodAffinityArgs) ToPodAffinityPtrOutput() PodAffinityPtrOutput { return i.ToPodAffinityPtrOutputWithContext(context.Background()) } @@ -39914,6 +45153,12 @@ func (i *podAffinityPtrType) ToPodAffinityPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(PodAffinityPtrOutput) } +func (i *podAffinityPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodAffinity] { + return pulumix.Output[*PodAffinity]{ + OutputState: i.ToPodAffinityPtrOutputWithContext(ctx).OutputState, + } +} + // Pod affinity is a group of inter pod affinity scheduling rules. type PodAffinityOutput struct{ *pulumi.OutputState } @@ -39939,6 +45184,12 @@ func (o PodAffinityOutput) ToPodAffinityPtrOutputWithContext(ctx context.Context }).(PodAffinityPtrOutput) } +func (o PodAffinityOutput) ToOutput(ctx context.Context) pulumix.Output[PodAffinity] { + return pulumix.Output[PodAffinity]{ + OutputState: o.OutputState, + } +} + // The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. func (o PodAffinityOutput) PreferredDuringSchedulingIgnoredDuringExecution() WeightedPodAffinityTermArrayOutput { return o.ApplyT(func(v PodAffinity) []WeightedPodAffinityTerm { @@ -39965,6 +45216,12 @@ func (o PodAffinityPtrOutput) ToPodAffinityPtrOutputWithContext(ctx context.Cont return o } +func (o PodAffinityPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodAffinity] { + return pulumix.Output[*PodAffinity]{ + OutputState: o.OutputState, + } +} + func (o PodAffinityPtrOutput) Elem() PodAffinityOutput { return o.ApplyT(func(v *PodAffinity) PodAffinity { if v != nil { @@ -40034,6 +45291,12 @@ func (i PodAffinityPatchArgs) ToPodAffinityPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodAffinityPatchOutput) } +func (i PodAffinityPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodAffinityPatch] { + return pulumix.Output[PodAffinityPatch]{ + OutputState: i.ToPodAffinityPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodAffinityPatchArgs) ToPodAffinityPatchPtrOutput() PodAffinityPatchPtrOutput { return i.ToPodAffinityPatchPtrOutputWithContext(context.Background()) } @@ -40075,6 +45338,12 @@ func (i *podAffinityPatchPtrType) ToPodAffinityPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodAffinityPatchPtrOutput) } +func (i *podAffinityPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodAffinityPatch] { + return pulumix.Output[*PodAffinityPatch]{ + OutputState: i.ToPodAffinityPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Pod affinity is a group of inter pod affinity scheduling rules. type PodAffinityPatchOutput struct{ *pulumi.OutputState } @@ -40100,6 +45369,12 @@ func (o PodAffinityPatchOutput) ToPodAffinityPatchPtrOutputWithContext(ctx conte }).(PodAffinityPatchPtrOutput) } +func (o PodAffinityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodAffinityPatch] { + return pulumix.Output[PodAffinityPatch]{ + OutputState: o.OutputState, + } +} + // The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. func (o PodAffinityPatchOutput) PreferredDuringSchedulingIgnoredDuringExecution() WeightedPodAffinityTermPatchArrayOutput { return o.ApplyT(func(v PodAffinityPatch) []WeightedPodAffinityTermPatch { @@ -40128,6 +45403,12 @@ func (o PodAffinityPatchPtrOutput) ToPodAffinityPatchPtrOutputWithContext(ctx co return o } +func (o PodAffinityPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodAffinityPatch] { + return pulumix.Output[*PodAffinityPatch]{ + OutputState: o.OutputState, + } +} + func (o PodAffinityPatchPtrOutput) Elem() PodAffinityPatchOutput { return o.ApplyT(func(v *PodAffinityPatch) PodAffinityPatch { if v != nil { @@ -40205,6 +45486,12 @@ func (i PodAffinityTermArgs) ToPodAffinityTermOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PodAffinityTermOutput) } +func (i PodAffinityTermArgs) ToOutput(ctx context.Context) pulumix.Output[PodAffinityTerm] { + return pulumix.Output[PodAffinityTerm]{ + OutputState: i.ToPodAffinityTermOutputWithContext(ctx).OutputState, + } +} + // PodAffinityTermArrayInput is an input type that accepts PodAffinityTermArray and PodAffinityTermArrayOutput values. // You can construct a concrete instance of `PodAffinityTermArrayInput` via: // @@ -40230,6 +45517,12 @@ func (i PodAffinityTermArray) ToPodAffinityTermArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodAffinityTermArrayOutput) } +func (i PodAffinityTermArray) ToOutput(ctx context.Context) pulumix.Output[[]PodAffinityTerm] { + return pulumix.Output[[]PodAffinityTerm]{ + OutputState: i.ToPodAffinityTermArrayOutputWithContext(ctx).OutputState, + } +} + // Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running type PodAffinityTermOutput struct{ *pulumi.OutputState } @@ -40245,6 +45538,12 @@ func (o PodAffinityTermOutput) ToPodAffinityTermOutputWithContext(ctx context.Co return o } +func (o PodAffinityTermOutput) ToOutput(ctx context.Context) pulumix.Output[PodAffinityTerm] { + return pulumix.Output[PodAffinityTerm]{ + OutputState: o.OutputState, + } +} + // A label query over a set of resources, in this case pods. func (o PodAffinityTermOutput) LabelSelector() metav1.LabelSelectorPtrOutput { return o.ApplyT(func(v PodAffinityTerm) *metav1.LabelSelector { return v.LabelSelector }).(metav1.LabelSelectorPtrOutput) @@ -40279,6 +45578,12 @@ func (o PodAffinityTermArrayOutput) ToPodAffinityTermArrayOutputWithContext(ctx return o } +func (o PodAffinityTermArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodAffinityTerm] { + return pulumix.Output[[]PodAffinityTerm]{ + OutputState: o.OutputState, + } +} + func (o PodAffinityTermArrayOutput) Index(i pulumi.IntInput) PodAffinityTermOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodAffinityTerm { return vs[0].([]PodAffinityTerm)[vs[1].(int)] @@ -40332,6 +45637,12 @@ func (i PodAffinityTermPatchArgs) ToPodAffinityTermPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodAffinityTermPatchOutput) } +func (i PodAffinityTermPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodAffinityTermPatch] { + return pulumix.Output[PodAffinityTermPatch]{ + OutputState: i.ToPodAffinityTermPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodAffinityTermPatchArgs) ToPodAffinityTermPatchPtrOutput() PodAffinityTermPatchPtrOutput { return i.ToPodAffinityTermPatchPtrOutputWithContext(context.Background()) } @@ -40373,6 +45684,12 @@ func (i *podAffinityTermPatchPtrType) ToPodAffinityTermPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PodAffinityTermPatchPtrOutput) } +func (i *podAffinityTermPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodAffinityTermPatch] { + return pulumix.Output[*PodAffinityTermPatch]{ + OutputState: i.ToPodAffinityTermPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodAffinityTermPatchArrayInput is an input type that accepts PodAffinityTermPatchArray and PodAffinityTermPatchArrayOutput values. // You can construct a concrete instance of `PodAffinityTermPatchArrayInput` via: // @@ -40398,6 +45715,12 @@ func (i PodAffinityTermPatchArray) ToPodAffinityTermPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodAffinityTermPatchArrayOutput) } +func (i PodAffinityTermPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodAffinityTermPatch] { + return pulumix.Output[[]PodAffinityTermPatch]{ + OutputState: i.ToPodAffinityTermPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running type PodAffinityTermPatchOutput struct{ *pulumi.OutputState } @@ -40423,6 +45746,12 @@ func (o PodAffinityTermPatchOutput) ToPodAffinityTermPatchPtrOutputWithContext(c }).(PodAffinityTermPatchPtrOutput) } +func (o PodAffinityTermPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodAffinityTermPatch] { + return pulumix.Output[PodAffinityTermPatch]{ + OutputState: o.OutputState, + } +} + // A label query over a set of resources, in this case pods. func (o PodAffinityTermPatchOutput) LabelSelector() metav1.LabelSelectorPatchPtrOutput { return o.ApplyT(func(v PodAffinityTermPatch) *metav1.LabelSelectorPatch { return v.LabelSelector }).(metav1.LabelSelectorPatchPtrOutput) @@ -40457,6 +45786,12 @@ func (o PodAffinityTermPatchPtrOutput) ToPodAffinityTermPatchPtrOutputWithContex return o } +func (o PodAffinityTermPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodAffinityTermPatch] { + return pulumix.Output[*PodAffinityTermPatch]{ + OutputState: o.OutputState, + } +} + func (o PodAffinityTermPatchPtrOutput) Elem() PodAffinityTermPatchOutput { return o.ApplyT(func(v *PodAffinityTermPatch) PodAffinityTermPatch { if v != nil { @@ -40521,6 +45856,12 @@ func (o PodAffinityTermPatchArrayOutput) ToPodAffinityTermPatchArrayOutputWithCo return o } +func (o PodAffinityTermPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodAffinityTermPatch] { + return pulumix.Output[[]PodAffinityTermPatch]{ + OutputState: o.OutputState, + } +} + func (o PodAffinityTermPatchArrayOutput) Index(i pulumi.IntInput) PodAffinityTermPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodAffinityTermPatch { return vs[0].([]PodAffinityTermPatch)[vs[1].(int)] @@ -40566,6 +45907,12 @@ func (i PodAntiAffinityArgs) ToPodAntiAffinityOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PodAntiAffinityOutput) } +func (i PodAntiAffinityArgs) ToOutput(ctx context.Context) pulumix.Output[PodAntiAffinity] { + return pulumix.Output[PodAntiAffinity]{ + OutputState: i.ToPodAntiAffinityOutputWithContext(ctx).OutputState, + } +} + func (i PodAntiAffinityArgs) ToPodAntiAffinityPtrOutput() PodAntiAffinityPtrOutput { return i.ToPodAntiAffinityPtrOutputWithContext(context.Background()) } @@ -40607,6 +45954,12 @@ func (i *podAntiAffinityPtrType) ToPodAntiAffinityPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(PodAntiAffinityPtrOutput) } +func (i *podAntiAffinityPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodAntiAffinity] { + return pulumix.Output[*PodAntiAffinity]{ + OutputState: i.ToPodAntiAffinityPtrOutputWithContext(ctx).OutputState, + } +} + // Pod anti affinity is a group of inter pod anti affinity scheduling rules. type PodAntiAffinityOutput struct{ *pulumi.OutputState } @@ -40632,6 +45985,12 @@ func (o PodAntiAffinityOutput) ToPodAntiAffinityPtrOutputWithContext(ctx context }).(PodAntiAffinityPtrOutput) } +func (o PodAntiAffinityOutput) ToOutput(ctx context.Context) pulumix.Output[PodAntiAffinity] { + return pulumix.Output[PodAntiAffinity]{ + OutputState: o.OutputState, + } +} + // The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. func (o PodAntiAffinityOutput) PreferredDuringSchedulingIgnoredDuringExecution() WeightedPodAffinityTermArrayOutput { return o.ApplyT(func(v PodAntiAffinity) []WeightedPodAffinityTerm { @@ -40658,6 +46017,12 @@ func (o PodAntiAffinityPtrOutput) ToPodAntiAffinityPtrOutputWithContext(ctx cont return o } +func (o PodAntiAffinityPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodAntiAffinity] { + return pulumix.Output[*PodAntiAffinity]{ + OutputState: o.OutputState, + } +} + func (o PodAntiAffinityPtrOutput) Elem() PodAntiAffinityOutput { return o.ApplyT(func(v *PodAntiAffinity) PodAntiAffinity { if v != nil { @@ -40727,6 +46092,12 @@ func (i PodAntiAffinityPatchArgs) ToPodAntiAffinityPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodAntiAffinityPatchOutput) } +func (i PodAntiAffinityPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodAntiAffinityPatch] { + return pulumix.Output[PodAntiAffinityPatch]{ + OutputState: i.ToPodAntiAffinityPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodAntiAffinityPatchArgs) ToPodAntiAffinityPatchPtrOutput() PodAntiAffinityPatchPtrOutput { return i.ToPodAntiAffinityPatchPtrOutputWithContext(context.Background()) } @@ -40768,6 +46139,12 @@ func (i *podAntiAffinityPatchPtrType) ToPodAntiAffinityPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PodAntiAffinityPatchPtrOutput) } +func (i *podAntiAffinityPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodAntiAffinityPatch] { + return pulumix.Output[*PodAntiAffinityPatch]{ + OutputState: i.ToPodAntiAffinityPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Pod anti affinity is a group of inter pod anti affinity scheduling rules. type PodAntiAffinityPatchOutput struct{ *pulumi.OutputState } @@ -40793,6 +46170,12 @@ func (o PodAntiAffinityPatchOutput) ToPodAntiAffinityPatchPtrOutputWithContext(c }).(PodAntiAffinityPatchPtrOutput) } +func (o PodAntiAffinityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodAntiAffinityPatch] { + return pulumix.Output[PodAntiAffinityPatch]{ + OutputState: o.OutputState, + } +} + // The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. func (o PodAntiAffinityPatchOutput) PreferredDuringSchedulingIgnoredDuringExecution() WeightedPodAffinityTermPatchArrayOutput { return o.ApplyT(func(v PodAntiAffinityPatch) []WeightedPodAffinityTermPatch { @@ -40821,6 +46204,12 @@ func (o PodAntiAffinityPatchPtrOutput) ToPodAntiAffinityPatchPtrOutputWithContex return o } +func (o PodAntiAffinityPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodAntiAffinityPatch] { + return pulumix.Output[*PodAntiAffinityPatch]{ + OutputState: o.OutputState, + } +} + func (o PodAntiAffinityPatchPtrOutput) Elem() PodAntiAffinityPatchOutput { return o.ApplyT(func(v *PodAntiAffinityPatch) PodAntiAffinityPatch { if v != nil { @@ -40906,6 +46295,12 @@ func (i PodConditionArgs) ToPodConditionOutputWithContext(ctx context.Context) P return pulumi.ToOutputWithContext(ctx, i).(PodConditionOutput) } +func (i PodConditionArgs) ToOutput(ctx context.Context) pulumix.Output[PodCondition] { + return pulumix.Output[PodCondition]{ + OutputState: i.ToPodConditionOutputWithContext(ctx).OutputState, + } +} + // PodConditionArrayInput is an input type that accepts PodConditionArray and PodConditionArrayOutput values. // You can construct a concrete instance of `PodConditionArrayInput` via: // @@ -40931,6 +46326,12 @@ func (i PodConditionArray) ToPodConditionArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PodConditionArrayOutput) } +func (i PodConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]PodCondition] { + return pulumix.Output[[]PodCondition]{ + OutputState: i.ToPodConditionArrayOutputWithContext(ctx).OutputState, + } +} + // PodCondition contains details for the current condition of this pod. type PodConditionOutput struct{ *pulumi.OutputState } @@ -40946,6 +46347,12 @@ func (o PodConditionOutput) ToPodConditionOutputWithContext(ctx context.Context) return o } +func (o PodConditionOutput) ToOutput(ctx context.Context) pulumix.Output[PodCondition] { + return pulumix.Output[PodCondition]{ + OutputState: o.OutputState, + } +} + // Last time we probed the condition. func (o PodConditionOutput) LastProbeTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PodCondition) *string { return v.LastProbeTime }).(pulumi.StringPtrOutput) @@ -40990,6 +46397,12 @@ func (o PodConditionArrayOutput) ToPodConditionArrayOutputWithContext(ctx contex return o } +func (o PodConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodCondition] { + return pulumix.Output[[]PodCondition]{ + OutputState: o.OutputState, + } +} + func (o PodConditionArrayOutput) Index(i pulumi.IntInput) PodConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodCondition { return vs[0].([]PodCondition)[vs[1].(int)] @@ -41051,6 +46464,12 @@ func (i PodConditionPatchArgs) ToPodConditionPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodConditionPatchOutput) } +func (i PodConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodConditionPatch] { + return pulumix.Output[PodConditionPatch]{ + OutputState: i.ToPodConditionPatchOutputWithContext(ctx).OutputState, + } +} + // PodConditionPatchArrayInput is an input type that accepts PodConditionPatchArray and PodConditionPatchArrayOutput values. // You can construct a concrete instance of `PodConditionPatchArrayInput` via: // @@ -41076,6 +46495,12 @@ func (i PodConditionPatchArray) ToPodConditionPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodConditionPatchArrayOutput) } +func (i PodConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodConditionPatch] { + return pulumix.Output[[]PodConditionPatch]{ + OutputState: i.ToPodConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodCondition contains details for the current condition of this pod. type PodConditionPatchOutput struct{ *pulumi.OutputState } @@ -41091,6 +46516,12 @@ func (o PodConditionPatchOutput) ToPodConditionPatchOutputWithContext(ctx contex return o } +func (o PodConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodConditionPatch] { + return pulumix.Output[PodConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time we probed the condition. func (o PodConditionPatchOutput) LastProbeTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PodConditionPatch) *string { return v.LastProbeTime }).(pulumi.StringPtrOutput) @@ -41135,6 +46566,12 @@ func (o PodConditionPatchArrayOutput) ToPodConditionPatchArrayOutputWithContext( return o } +func (o PodConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodConditionPatch] { + return pulumix.Output[[]PodConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o PodConditionPatchArrayOutput) Index(i pulumi.IntInput) PodConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodConditionPatch { return vs[0].([]PodConditionPatch)[vs[1].(int)] @@ -41184,6 +46621,12 @@ func (i PodDNSConfigArgs) ToPodDNSConfigOutputWithContext(ctx context.Context) P return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigOutput) } +func (i PodDNSConfigArgs) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfig] { + return pulumix.Output[PodDNSConfig]{ + OutputState: i.ToPodDNSConfigOutputWithContext(ctx).OutputState, + } +} + func (i PodDNSConfigArgs) ToPodDNSConfigPtrOutput() PodDNSConfigPtrOutput { return i.ToPodDNSConfigPtrOutputWithContext(context.Background()) } @@ -41225,6 +46668,12 @@ func (i *podDNSConfigPtrType) ToPodDNSConfigPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigPtrOutput) } +func (i *podDNSConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDNSConfig] { + return pulumix.Output[*PodDNSConfig]{ + OutputState: i.ToPodDNSConfigPtrOutputWithContext(ctx).OutputState, + } +} + // PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. type PodDNSConfigOutput struct{ *pulumi.OutputState } @@ -41250,6 +46699,12 @@ func (o PodDNSConfigOutput) ToPodDNSConfigPtrOutputWithContext(ctx context.Conte }).(PodDNSConfigPtrOutput) } +func (o PodDNSConfigOutput) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfig] { + return pulumix.Output[PodDNSConfig]{ + OutputState: o.OutputState, + } +} + // A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. func (o PodDNSConfigOutput) Nameservers() pulumi.StringArrayOutput { return o.ApplyT(func(v PodDNSConfig) []string { return v.Nameservers }).(pulumi.StringArrayOutput) @@ -41279,6 +46734,12 @@ func (o PodDNSConfigPtrOutput) ToPodDNSConfigPtrOutputWithContext(ctx context.Co return o } +func (o PodDNSConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDNSConfig] { + return pulumix.Output[*PodDNSConfig]{ + OutputState: o.OutputState, + } +} + func (o PodDNSConfigPtrOutput) Elem() PodDNSConfigOutput { return o.ApplyT(func(v *PodDNSConfig) PodDNSConfig { if v != nil { @@ -41356,6 +46817,12 @@ func (i PodDNSConfigOptionArgs) ToPodDNSConfigOptionOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigOptionOutput) } +func (i PodDNSConfigOptionArgs) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfigOption] { + return pulumix.Output[PodDNSConfigOption]{ + OutputState: i.ToPodDNSConfigOptionOutputWithContext(ctx).OutputState, + } +} + // PodDNSConfigOptionArrayInput is an input type that accepts PodDNSConfigOptionArray and PodDNSConfigOptionArrayOutput values. // You can construct a concrete instance of `PodDNSConfigOptionArrayInput` via: // @@ -41381,6 +46848,12 @@ func (i PodDNSConfigOptionArray) ToPodDNSConfigOptionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigOptionArrayOutput) } +func (i PodDNSConfigOptionArray) ToOutput(ctx context.Context) pulumix.Output[[]PodDNSConfigOption] { + return pulumix.Output[[]PodDNSConfigOption]{ + OutputState: i.ToPodDNSConfigOptionArrayOutputWithContext(ctx).OutputState, + } +} + // PodDNSConfigOption defines DNS resolver options of a pod. type PodDNSConfigOptionOutput struct{ *pulumi.OutputState } @@ -41396,6 +46869,12 @@ func (o PodDNSConfigOptionOutput) ToPodDNSConfigOptionOutputWithContext(ctx cont return o } +func (o PodDNSConfigOptionOutput) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfigOption] { + return pulumix.Output[PodDNSConfigOption]{ + OutputState: o.OutputState, + } +} + // Required. func (o PodDNSConfigOptionOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDNSConfigOption) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -41419,6 +46898,12 @@ func (o PodDNSConfigOptionArrayOutput) ToPodDNSConfigOptionArrayOutputWithContex return o } +func (o PodDNSConfigOptionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodDNSConfigOption] { + return pulumix.Output[[]PodDNSConfigOption]{ + OutputState: o.OutputState, + } +} + func (o PodDNSConfigOptionArrayOutput) Index(i pulumi.IntInput) PodDNSConfigOptionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodDNSConfigOption { return vs[0].([]PodDNSConfigOption)[vs[1].(int)] @@ -41462,6 +46947,12 @@ func (i PodDNSConfigOptionPatchArgs) ToPodDNSConfigOptionPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigOptionPatchOutput) } +func (i PodDNSConfigOptionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfigOptionPatch] { + return pulumix.Output[PodDNSConfigOptionPatch]{ + OutputState: i.ToPodDNSConfigOptionPatchOutputWithContext(ctx).OutputState, + } +} + // PodDNSConfigOptionPatchArrayInput is an input type that accepts PodDNSConfigOptionPatchArray and PodDNSConfigOptionPatchArrayOutput values. // You can construct a concrete instance of `PodDNSConfigOptionPatchArrayInput` via: // @@ -41487,6 +46978,12 @@ func (i PodDNSConfigOptionPatchArray) ToPodDNSConfigOptionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigOptionPatchArrayOutput) } +func (i PodDNSConfigOptionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodDNSConfigOptionPatch] { + return pulumix.Output[[]PodDNSConfigOptionPatch]{ + OutputState: i.ToPodDNSConfigOptionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodDNSConfigOption defines DNS resolver options of a pod. type PodDNSConfigOptionPatchOutput struct{ *pulumi.OutputState } @@ -41502,6 +46999,12 @@ func (o PodDNSConfigOptionPatchOutput) ToPodDNSConfigOptionPatchOutputWithContex return o } +func (o PodDNSConfigOptionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfigOptionPatch] { + return pulumix.Output[PodDNSConfigOptionPatch]{ + OutputState: o.OutputState, + } +} + // Required. func (o PodDNSConfigOptionPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDNSConfigOptionPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -41525,6 +47028,12 @@ func (o PodDNSConfigOptionPatchArrayOutput) ToPodDNSConfigOptionPatchArrayOutput return o } +func (o PodDNSConfigOptionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodDNSConfigOptionPatch] { + return pulumix.Output[[]PodDNSConfigOptionPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDNSConfigOptionPatchArrayOutput) Index(i pulumi.IntInput) PodDNSConfigOptionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodDNSConfigOptionPatch { return vs[0].([]PodDNSConfigOptionPatch)[vs[1].(int)] @@ -41574,6 +47083,12 @@ func (i PodDNSConfigPatchArgs) ToPodDNSConfigPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigPatchOutput) } +func (i PodDNSConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfigPatch] { + return pulumix.Output[PodDNSConfigPatch]{ + OutputState: i.ToPodDNSConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodDNSConfigPatchArgs) ToPodDNSConfigPatchPtrOutput() PodDNSConfigPatchPtrOutput { return i.ToPodDNSConfigPatchPtrOutputWithContext(context.Background()) } @@ -41615,6 +47130,12 @@ func (i *podDNSConfigPatchPtrType) ToPodDNSConfigPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(PodDNSConfigPatchPtrOutput) } +func (i *podDNSConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDNSConfigPatch] { + return pulumix.Output[*PodDNSConfigPatch]{ + OutputState: i.ToPodDNSConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. type PodDNSConfigPatchOutput struct{ *pulumi.OutputState } @@ -41640,6 +47161,12 @@ func (o PodDNSConfigPatchOutput) ToPodDNSConfigPatchPtrOutputWithContext(ctx con }).(PodDNSConfigPatchPtrOutput) } +func (o PodDNSConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodDNSConfigPatch] { + return pulumix.Output[PodDNSConfigPatch]{ + OutputState: o.OutputState, + } +} + // A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. func (o PodDNSConfigPatchOutput) Nameservers() pulumi.StringArrayOutput { return o.ApplyT(func(v PodDNSConfigPatch) []string { return v.Nameservers }).(pulumi.StringArrayOutput) @@ -41669,6 +47196,12 @@ func (o PodDNSConfigPatchPtrOutput) ToPodDNSConfigPatchPtrOutputWithContext(ctx return o } +func (o PodDNSConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDNSConfigPatch] { + return pulumix.Output[*PodDNSConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDNSConfigPatchPtrOutput) Elem() PodDNSConfigPatchOutput { return o.ApplyT(func(v *PodDNSConfigPatch) PodDNSConfigPatch { if v != nil { @@ -41744,6 +47277,12 @@ func (i PodIPArgs) ToPodIPOutputWithContext(ctx context.Context) PodIPOutput { return pulumi.ToOutputWithContext(ctx, i).(PodIPOutput) } +func (i PodIPArgs) ToOutput(ctx context.Context) pulumix.Output[PodIP] { + return pulumix.Output[PodIP]{ + OutputState: i.ToPodIPOutputWithContext(ctx).OutputState, + } +} + // PodIPArrayInput is an input type that accepts PodIPArray and PodIPArrayOutput values. // You can construct a concrete instance of `PodIPArrayInput` via: // @@ -41769,6 +47308,12 @@ func (i PodIPArray) ToPodIPArrayOutputWithContext(ctx context.Context) PodIPArra return pulumi.ToOutputWithContext(ctx, i).(PodIPArrayOutput) } +func (i PodIPArray) ToOutput(ctx context.Context) pulumix.Output[[]PodIP] { + return pulumix.Output[[]PodIP]{ + OutputState: i.ToPodIPArrayOutputWithContext(ctx).OutputState, + } +} + // PodIP represents a single IP address allocated to the pod. type PodIPOutput struct{ *pulumi.OutputState } @@ -41784,6 +47329,12 @@ func (o PodIPOutput) ToPodIPOutputWithContext(ctx context.Context) PodIPOutput { return o } +func (o PodIPOutput) ToOutput(ctx context.Context) pulumix.Output[PodIP] { + return pulumix.Output[PodIP]{ + OutputState: o.OutputState, + } +} + // IP is the IP address assigned to the pod func (o PodIPOutput) Ip() pulumi.StringPtrOutput { return o.ApplyT(func(v PodIP) *string { return v.Ip }).(pulumi.StringPtrOutput) @@ -41803,6 +47354,12 @@ func (o PodIPArrayOutput) ToPodIPArrayOutputWithContext(ctx context.Context) Pod return o } +func (o PodIPArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodIP] { + return pulumix.Output[[]PodIP]{ + OutputState: o.OutputState, + } +} + func (o PodIPArrayOutput) Index(i pulumi.IntInput) PodIPOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodIP { return vs[0].([]PodIP)[vs[1].(int)] @@ -41844,6 +47401,12 @@ func (i PodIPPatchArgs) ToPodIPPatchOutputWithContext(ctx context.Context) PodIP return pulumi.ToOutputWithContext(ctx, i).(PodIPPatchOutput) } +func (i PodIPPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodIPPatch] { + return pulumix.Output[PodIPPatch]{ + OutputState: i.ToPodIPPatchOutputWithContext(ctx).OutputState, + } +} + // PodIPPatchArrayInput is an input type that accepts PodIPPatchArray and PodIPPatchArrayOutput values. // You can construct a concrete instance of `PodIPPatchArrayInput` via: // @@ -41869,6 +47432,12 @@ func (i PodIPPatchArray) ToPodIPPatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PodIPPatchArrayOutput) } +func (i PodIPPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodIPPatch] { + return pulumix.Output[[]PodIPPatch]{ + OutputState: i.ToPodIPPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodIP represents a single IP address allocated to the pod. type PodIPPatchOutput struct{ *pulumi.OutputState } @@ -41884,6 +47453,12 @@ func (o PodIPPatchOutput) ToPodIPPatchOutputWithContext(ctx context.Context) Pod return o } +func (o PodIPPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodIPPatch] { + return pulumix.Output[PodIPPatch]{ + OutputState: o.OutputState, + } +} + // IP is the IP address assigned to the pod func (o PodIPPatchOutput) Ip() pulumi.StringPtrOutput { return o.ApplyT(func(v PodIPPatch) *string { return v.Ip }).(pulumi.StringPtrOutput) @@ -41903,6 +47478,12 @@ func (o PodIPPatchArrayOutput) ToPodIPPatchArrayOutputWithContext(ctx context.Co return o } +func (o PodIPPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodIPPatch] { + return pulumix.Output[[]PodIPPatch]{ + OutputState: o.OutputState, + } +} + func (o PodIPPatchArrayOutput) Index(i pulumi.IntInput) PodIPPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodIPPatch { return vs[0].([]PodIPPatch)[vs[1].(int)] @@ -41956,6 +47537,12 @@ func (i PodListTypeArgs) ToPodListTypeOutputWithContext(ctx context.Context) Pod return pulumi.ToOutputWithContext(ctx, i).(PodListTypeOutput) } +func (i PodListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodListType] { + return pulumix.Output[PodListType]{ + OutputState: i.ToPodListTypeOutputWithContext(ctx).OutputState, + } +} + // PodList is a list of Pods. type PodListTypeOutput struct{ *pulumi.OutputState } @@ -41971,6 +47558,12 @@ func (o PodListTypeOutput) ToPodListTypeOutputWithContext(ctx context.Context) P return o } +func (o PodListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodListType] { + return pulumix.Output[PodListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -42026,6 +47619,12 @@ func (i PodOSArgs) ToPodOSOutputWithContext(ctx context.Context) PodOSOutput { return pulumi.ToOutputWithContext(ctx, i).(PodOSOutput) } +func (i PodOSArgs) ToOutput(ctx context.Context) pulumix.Output[PodOS] { + return pulumix.Output[PodOS]{ + OutputState: i.ToPodOSOutputWithContext(ctx).OutputState, + } +} + func (i PodOSArgs) ToPodOSPtrOutput() PodOSPtrOutput { return i.ToPodOSPtrOutputWithContext(context.Background()) } @@ -42067,6 +47666,12 @@ func (i *podOSPtrType) ToPodOSPtrOutputWithContext(ctx context.Context) PodOSPtr return pulumi.ToOutputWithContext(ctx, i).(PodOSPtrOutput) } +func (i *podOSPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodOS] { + return pulumix.Output[*PodOS]{ + OutputState: i.ToPodOSPtrOutputWithContext(ctx).OutputState, + } +} + // PodOS defines the OS parameters of a pod. type PodOSOutput struct{ *pulumi.OutputState } @@ -42092,6 +47697,12 @@ func (o PodOSOutput) ToPodOSPtrOutputWithContext(ctx context.Context) PodOSPtrOu }).(PodOSPtrOutput) } +func (o PodOSOutput) ToOutput(ctx context.Context) pulumix.Output[PodOS] { + return pulumix.Output[PodOS]{ + OutputState: o.OutputState, + } +} + // Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null func (o PodOSOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PodOS) string { return v.Name }).(pulumi.StringOutput) @@ -42111,6 +47722,12 @@ func (o PodOSPtrOutput) ToPodOSPtrOutputWithContext(ctx context.Context) PodOSPt return o } +func (o PodOSPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodOS] { + return pulumix.Output[*PodOS]{ + OutputState: o.OutputState, + } +} + func (o PodOSPtrOutput) Elem() PodOSOutput { return o.ApplyT(func(v *PodOS) PodOS { if v != nil { @@ -42166,6 +47783,12 @@ func (i PodOSPatchArgs) ToPodOSPatchOutputWithContext(ctx context.Context) PodOS return pulumi.ToOutputWithContext(ctx, i).(PodOSPatchOutput) } +func (i PodOSPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodOSPatch] { + return pulumix.Output[PodOSPatch]{ + OutputState: i.ToPodOSPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodOSPatchArgs) ToPodOSPatchPtrOutput() PodOSPatchPtrOutput { return i.ToPodOSPatchPtrOutputWithContext(context.Background()) } @@ -42207,6 +47830,12 @@ func (i *podOSPatchPtrType) ToPodOSPatchPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(PodOSPatchPtrOutput) } +func (i *podOSPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodOSPatch] { + return pulumix.Output[*PodOSPatch]{ + OutputState: i.ToPodOSPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodOS defines the OS parameters of a pod. type PodOSPatchOutput struct{ *pulumi.OutputState } @@ -42232,6 +47861,12 @@ func (o PodOSPatchOutput) ToPodOSPatchPtrOutputWithContext(ctx context.Context) }).(PodOSPatchPtrOutput) } +func (o PodOSPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodOSPatch] { + return pulumix.Output[PodOSPatch]{ + OutputState: o.OutputState, + } +} + // Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null func (o PodOSPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PodOSPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -42251,6 +47886,12 @@ func (o PodOSPatchPtrOutput) ToPodOSPatchPtrOutputWithContext(ctx context.Contex return o } +func (o PodOSPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodOSPatch] { + return pulumix.Output[*PodOSPatch]{ + OutputState: o.OutputState, + } +} + func (o PodOSPatchPtrOutput) Elem() PodOSPatchOutput { return o.ApplyT(func(v *PodOSPatch) PodOSPatch { if v != nil { @@ -42352,6 +47993,12 @@ func (i PodPatchTypeArgs) ToPodPatchTypeOutputWithContext(ctx context.Context) P return pulumi.ToOutputWithContext(ctx, i).(PodPatchTypeOutput) } +func (i PodPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodPatchType] { + return pulumix.Output[PodPatchType]{ + OutputState: i.ToPodPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts. // // This resource waits until its status is ready before registering success @@ -42382,6 +48029,12 @@ func (o PodPatchTypeOutput) ToPodPatchTypeOutputWithContext(ctx context.Context) return o } +func (o PodPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodPatchType] { + return pulumix.Output[PodPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -42442,6 +48095,12 @@ func (i PodReadinessGateArgs) ToPodReadinessGateOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodReadinessGateOutput) } +func (i PodReadinessGateArgs) ToOutput(ctx context.Context) pulumix.Output[PodReadinessGate] { + return pulumix.Output[PodReadinessGate]{ + OutputState: i.ToPodReadinessGateOutputWithContext(ctx).OutputState, + } +} + // PodReadinessGateArrayInput is an input type that accepts PodReadinessGateArray and PodReadinessGateArrayOutput values. // You can construct a concrete instance of `PodReadinessGateArrayInput` via: // @@ -42467,6 +48126,12 @@ func (i PodReadinessGateArray) ToPodReadinessGateArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PodReadinessGateArrayOutput) } +func (i PodReadinessGateArray) ToOutput(ctx context.Context) pulumix.Output[[]PodReadinessGate] { + return pulumix.Output[[]PodReadinessGate]{ + OutputState: i.ToPodReadinessGateArrayOutputWithContext(ctx).OutputState, + } +} + // PodReadinessGate contains the reference to a pod condition type PodReadinessGateOutput struct{ *pulumi.OutputState } @@ -42482,6 +48147,12 @@ func (o PodReadinessGateOutput) ToPodReadinessGateOutputWithContext(ctx context. return o } +func (o PodReadinessGateOutput) ToOutput(ctx context.Context) pulumix.Output[PodReadinessGate] { + return pulumix.Output[PodReadinessGate]{ + OutputState: o.OutputState, + } +} + // ConditionType refers to a condition in the pod's condition list with matching type. func (o PodReadinessGateOutput) ConditionType() pulumi.StringOutput { return o.ApplyT(func(v PodReadinessGate) string { return v.ConditionType }).(pulumi.StringOutput) @@ -42501,6 +48172,12 @@ func (o PodReadinessGateArrayOutput) ToPodReadinessGateArrayOutputWithContext(ct return o } +func (o PodReadinessGateArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodReadinessGate] { + return pulumix.Output[[]PodReadinessGate]{ + OutputState: o.OutputState, + } +} + func (o PodReadinessGateArrayOutput) Index(i pulumi.IntInput) PodReadinessGateOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodReadinessGate { return vs[0].([]PodReadinessGate)[vs[1].(int)] @@ -42542,6 +48219,12 @@ func (i PodReadinessGatePatchArgs) ToPodReadinessGatePatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodReadinessGatePatchOutput) } +func (i PodReadinessGatePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodReadinessGatePatch] { + return pulumix.Output[PodReadinessGatePatch]{ + OutputState: i.ToPodReadinessGatePatchOutputWithContext(ctx).OutputState, + } +} + // PodReadinessGatePatchArrayInput is an input type that accepts PodReadinessGatePatchArray and PodReadinessGatePatchArrayOutput values. // You can construct a concrete instance of `PodReadinessGatePatchArrayInput` via: // @@ -42567,6 +48250,12 @@ func (i PodReadinessGatePatchArray) ToPodReadinessGatePatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodReadinessGatePatchArrayOutput) } +func (i PodReadinessGatePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodReadinessGatePatch] { + return pulumix.Output[[]PodReadinessGatePatch]{ + OutputState: i.ToPodReadinessGatePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodReadinessGate contains the reference to a pod condition type PodReadinessGatePatchOutput struct{ *pulumi.OutputState } @@ -42582,6 +48271,12 @@ func (o PodReadinessGatePatchOutput) ToPodReadinessGatePatchOutputWithContext(ct return o } +func (o PodReadinessGatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodReadinessGatePatch] { + return pulumix.Output[PodReadinessGatePatch]{ + OutputState: o.OutputState, + } +} + // ConditionType refers to a condition in the pod's condition list with matching type. func (o PodReadinessGatePatchOutput) ConditionType() pulumi.StringPtrOutput { return o.ApplyT(func(v PodReadinessGatePatch) *string { return v.ConditionType }).(pulumi.StringPtrOutput) @@ -42601,6 +48296,12 @@ func (o PodReadinessGatePatchArrayOutput) ToPodReadinessGatePatchArrayOutputWith return o } +func (o PodReadinessGatePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodReadinessGatePatch] { + return pulumix.Output[[]PodReadinessGatePatch]{ + OutputState: o.OutputState, + } +} + func (o PodReadinessGatePatchArrayOutput) Index(i pulumi.IntInput) PodReadinessGatePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodReadinessGatePatch { return vs[0].([]PodReadinessGatePatch)[vs[1].(int)] @@ -42646,6 +48347,12 @@ func (i PodResourceClaimArgs) ToPodResourceClaimOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimOutput) } +func (i PodResourceClaimArgs) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaim] { + return pulumix.Output[PodResourceClaim]{ + OutputState: i.ToPodResourceClaimOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaimArrayInput is an input type that accepts PodResourceClaimArray and PodResourceClaimArrayOutput values. // You can construct a concrete instance of `PodResourceClaimArrayInput` via: // @@ -42671,6 +48378,12 @@ func (i PodResourceClaimArray) ToPodResourceClaimArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimArrayOutput) } +func (i PodResourceClaimArray) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaim] { + return pulumix.Output[[]PodResourceClaim]{ + OutputState: i.ToPodResourceClaimArrayOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaim references exactly one ResourceClaim through a ClaimSource. It adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name. type PodResourceClaimOutput struct{ *pulumi.OutputState } @@ -42686,6 +48399,12 @@ func (o PodResourceClaimOutput) ToPodResourceClaimOutputWithContext(ctx context. return o } +func (o PodResourceClaimOutput) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaim] { + return pulumix.Output[PodResourceClaim]{ + OutputState: o.OutputState, + } +} + // Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL. func (o PodResourceClaimOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PodResourceClaim) string { return v.Name }).(pulumi.StringOutput) @@ -42710,6 +48429,12 @@ func (o PodResourceClaimArrayOutput) ToPodResourceClaimArrayOutputWithContext(ct return o } +func (o PodResourceClaimArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaim] { + return pulumix.Output[[]PodResourceClaim]{ + OutputState: o.OutputState, + } +} + func (o PodResourceClaimArrayOutput) Index(i pulumi.IntInput) PodResourceClaimOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodResourceClaim { return vs[0].([]PodResourceClaim)[vs[1].(int)] @@ -42755,6 +48480,12 @@ func (i PodResourceClaimPatchArgs) ToPodResourceClaimPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimPatchOutput) } +func (i PodResourceClaimPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaimPatch] { + return pulumix.Output[PodResourceClaimPatch]{ + OutputState: i.ToPodResourceClaimPatchOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaimPatchArrayInput is an input type that accepts PodResourceClaimPatchArray and PodResourceClaimPatchArrayOutput values. // You can construct a concrete instance of `PodResourceClaimPatchArrayInput` via: // @@ -42780,6 +48511,12 @@ func (i PodResourceClaimPatchArray) ToPodResourceClaimPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimPatchArrayOutput) } +func (i PodResourceClaimPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaimPatch] { + return pulumix.Output[[]PodResourceClaimPatch]{ + OutputState: i.ToPodResourceClaimPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaim references exactly one ResourceClaim through a ClaimSource. It adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name. type PodResourceClaimPatchOutput struct{ *pulumi.OutputState } @@ -42795,6 +48532,12 @@ func (o PodResourceClaimPatchOutput) ToPodResourceClaimPatchOutputWithContext(ct return o } +func (o PodResourceClaimPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaimPatch] { + return pulumix.Output[PodResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + // Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL. func (o PodResourceClaimPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PodResourceClaimPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -42819,6 +48562,12 @@ func (o PodResourceClaimPatchArrayOutput) ToPodResourceClaimPatchArrayOutputWith return o } +func (o PodResourceClaimPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaimPatch] { + return pulumix.Output[[]PodResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o PodResourceClaimPatchArrayOutput) Index(i pulumi.IntInput) PodResourceClaimPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodResourceClaimPatch { return vs[0].([]PodResourceClaimPatch)[vs[1].(int)] @@ -42864,6 +48613,12 @@ func (i PodResourceClaimStatusArgs) ToPodResourceClaimStatusOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimStatusOutput) } +func (i PodResourceClaimStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaimStatus] { + return pulumix.Output[PodResourceClaimStatus]{ + OutputState: i.ToPodResourceClaimStatusOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaimStatusArrayInput is an input type that accepts PodResourceClaimStatusArray and PodResourceClaimStatusArrayOutput values. // You can construct a concrete instance of `PodResourceClaimStatusArrayInput` via: // @@ -42889,6 +48644,12 @@ func (i PodResourceClaimStatusArray) ToPodResourceClaimStatusArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimStatusArrayOutput) } +func (i PodResourceClaimStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaimStatus] { + return pulumix.Output[[]PodResourceClaimStatus]{ + OutputState: i.ToPodResourceClaimStatusArrayOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaimStatus is stored in the PodStatus for each PodResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim. type PodResourceClaimStatusOutput struct{ *pulumi.OutputState } @@ -42904,6 +48665,12 @@ func (o PodResourceClaimStatusOutput) ToPodResourceClaimStatusOutputWithContext( return o } +func (o PodResourceClaimStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaimStatus] { + return pulumix.Output[PodResourceClaimStatus]{ + OutputState: o.OutputState, + } +} + // Name uniquely identifies this resource claim inside the pod. This must match the name of an entry in pod.spec.resourceClaims, which implies that the string must be a DNS_LABEL. func (o PodResourceClaimStatusOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PodResourceClaimStatus) string { return v.Name }).(pulumi.StringOutput) @@ -42928,6 +48695,12 @@ func (o PodResourceClaimStatusArrayOutput) ToPodResourceClaimStatusArrayOutputWi return o } +func (o PodResourceClaimStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaimStatus] { + return pulumix.Output[[]PodResourceClaimStatus]{ + OutputState: o.OutputState, + } +} + func (o PodResourceClaimStatusArrayOutput) Index(i pulumi.IntInput) PodResourceClaimStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodResourceClaimStatus { return vs[0].([]PodResourceClaimStatus)[vs[1].(int)] @@ -42973,6 +48746,12 @@ func (i PodResourceClaimStatusPatchArgs) ToPodResourceClaimStatusPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimStatusPatchOutput) } +func (i PodResourceClaimStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaimStatusPatch] { + return pulumix.Output[PodResourceClaimStatusPatch]{ + OutputState: i.ToPodResourceClaimStatusPatchOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaimStatusPatchArrayInput is an input type that accepts PodResourceClaimStatusPatchArray and PodResourceClaimStatusPatchArrayOutput values. // You can construct a concrete instance of `PodResourceClaimStatusPatchArrayInput` via: // @@ -42998,6 +48777,12 @@ func (i PodResourceClaimStatusPatchArray) ToPodResourceClaimStatusPatchArrayOutp return pulumi.ToOutputWithContext(ctx, i).(PodResourceClaimStatusPatchArrayOutput) } +func (i PodResourceClaimStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaimStatusPatch] { + return pulumix.Output[[]PodResourceClaimStatusPatch]{ + OutputState: i.ToPodResourceClaimStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodResourceClaimStatus is stored in the PodStatus for each PodResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim. type PodResourceClaimStatusPatchOutput struct{ *pulumi.OutputState } @@ -43013,6 +48798,12 @@ func (o PodResourceClaimStatusPatchOutput) ToPodResourceClaimStatusPatchOutputWi return o } +func (o PodResourceClaimStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodResourceClaimStatusPatch] { + return pulumix.Output[PodResourceClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + // Name uniquely identifies this resource claim inside the pod. This must match the name of an entry in pod.spec.resourceClaims, which implies that the string must be a DNS_LABEL. func (o PodResourceClaimStatusPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PodResourceClaimStatusPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -43037,6 +48828,12 @@ func (o PodResourceClaimStatusPatchArrayOutput) ToPodResourceClaimStatusPatchArr return o } +func (o PodResourceClaimStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodResourceClaimStatusPatch] { + return pulumix.Output[[]PodResourceClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodResourceClaimStatusPatchArrayOutput) Index(i pulumi.IntInput) PodResourceClaimStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodResourceClaimStatusPatch { return vs[0].([]PodResourceClaimStatusPatch)[vs[1].(int)] @@ -43078,6 +48875,12 @@ func (i PodSchedulingGateArgs) ToPodSchedulingGateOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingGateOutput) } +func (i PodSchedulingGateArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingGate] { + return pulumix.Output[PodSchedulingGate]{ + OutputState: i.ToPodSchedulingGateOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingGateArrayInput is an input type that accepts PodSchedulingGateArray and PodSchedulingGateArrayOutput values. // You can construct a concrete instance of `PodSchedulingGateArrayInput` via: // @@ -43103,6 +48906,12 @@ func (i PodSchedulingGateArray) ToPodSchedulingGateArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingGateArrayOutput) } +func (i PodSchedulingGateArray) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingGate] { + return pulumix.Output[[]PodSchedulingGate]{ + OutputState: i.ToPodSchedulingGateArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingGate is associated to a Pod to guard its scheduling. type PodSchedulingGateOutput struct{ *pulumi.OutputState } @@ -43118,6 +48927,12 @@ func (o PodSchedulingGateOutput) ToPodSchedulingGateOutputWithContext(ctx contex return o } +func (o PodSchedulingGateOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingGate] { + return pulumix.Output[PodSchedulingGate]{ + OutputState: o.OutputState, + } +} + // Name of the scheduling gate. Each scheduling gate must have a unique name field. func (o PodSchedulingGateOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PodSchedulingGate) string { return v.Name }).(pulumi.StringOutput) @@ -43137,6 +48952,12 @@ func (o PodSchedulingGateArrayOutput) ToPodSchedulingGateArrayOutputWithContext( return o } +func (o PodSchedulingGateArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingGate] { + return pulumix.Output[[]PodSchedulingGate]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingGateArrayOutput) Index(i pulumi.IntInput) PodSchedulingGateOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodSchedulingGate { return vs[0].([]PodSchedulingGate)[vs[1].(int)] @@ -43178,6 +48999,12 @@ func (i PodSchedulingGatePatchArgs) ToPodSchedulingGatePatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingGatePatchOutput) } +func (i PodSchedulingGatePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingGatePatch] { + return pulumix.Output[PodSchedulingGatePatch]{ + OutputState: i.ToPodSchedulingGatePatchOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingGatePatchArrayInput is an input type that accepts PodSchedulingGatePatchArray and PodSchedulingGatePatchArrayOutput values. // You can construct a concrete instance of `PodSchedulingGatePatchArrayInput` via: // @@ -43203,6 +49030,12 @@ func (i PodSchedulingGatePatchArray) ToPodSchedulingGatePatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingGatePatchArrayOutput) } +func (i PodSchedulingGatePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingGatePatch] { + return pulumix.Output[[]PodSchedulingGatePatch]{ + OutputState: i.ToPodSchedulingGatePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingGate is associated to a Pod to guard its scheduling. type PodSchedulingGatePatchOutput struct{ *pulumi.OutputState } @@ -43218,6 +49051,12 @@ func (o PodSchedulingGatePatchOutput) ToPodSchedulingGatePatchOutputWithContext( return o } +func (o PodSchedulingGatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingGatePatch] { + return pulumix.Output[PodSchedulingGatePatch]{ + OutputState: o.OutputState, + } +} + // Name of the scheduling gate. Each scheduling gate must have a unique name field. func (o PodSchedulingGatePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingGatePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -43237,6 +49076,12 @@ func (o PodSchedulingGatePatchArrayOutput) ToPodSchedulingGatePatchArrayOutputWi return o } +func (o PodSchedulingGatePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingGatePatch] { + return pulumix.Output[[]PodSchedulingGatePatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingGatePatchArrayOutput) Index(i pulumi.IntInput) PodSchedulingGatePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodSchedulingGatePatch { return vs[0].([]PodSchedulingGatePatch)[vs[1].(int)] @@ -43322,6 +49167,12 @@ func (i PodSecurityContextArgs) ToPodSecurityContextOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityContextOutput) } +func (i PodSecurityContextArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityContext] { + return pulumix.Output[PodSecurityContext]{ + OutputState: i.ToPodSecurityContextOutputWithContext(ctx).OutputState, + } +} + func (i PodSecurityContextArgs) ToPodSecurityContextPtrOutput() PodSecurityContextPtrOutput { return i.ToPodSecurityContextPtrOutputWithContext(context.Background()) } @@ -43363,6 +49214,12 @@ func (i *podSecurityContextPtrType) ToPodSecurityContextPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSecurityContextPtrOutput) } +func (i *podSecurityContextPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityContext] { + return pulumix.Output[*PodSecurityContext]{ + OutputState: i.ToPodSecurityContextPtrOutputWithContext(ctx).OutputState, + } +} + // PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext. type PodSecurityContextOutput struct{ *pulumi.OutputState } @@ -43388,6 +49245,12 @@ func (o PodSecurityContextOutput) ToPodSecurityContextPtrOutputWithContext(ctx c }).(PodSecurityContextPtrOutput) } +func (o PodSecurityContextOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityContext] { + return pulumix.Output[PodSecurityContext]{ + OutputState: o.OutputState, + } +} + // A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: // // 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- @@ -43456,6 +49319,12 @@ func (o PodSecurityContextPtrOutput) ToPodSecurityContextPtrOutputWithContext(ct return o } +func (o PodSecurityContextPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityContext] { + return pulumix.Output[*PodSecurityContext]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityContextPtrOutput) Elem() PodSecurityContextOutput { return o.ApplyT(func(v *PodSecurityContext) PodSecurityContext { if v != nil { @@ -43649,6 +49518,12 @@ func (i PodSecurityContextPatchArgs) ToPodSecurityContextPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodSecurityContextPatchOutput) } +func (i PodSecurityContextPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityContextPatch] { + return pulumix.Output[PodSecurityContextPatch]{ + OutputState: i.ToPodSecurityContextPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSecurityContextPatchArgs) ToPodSecurityContextPatchPtrOutput() PodSecurityContextPatchPtrOutput { return i.ToPodSecurityContextPatchPtrOutputWithContext(context.Background()) } @@ -43690,6 +49565,12 @@ func (i *podSecurityContextPatchPtrType) ToPodSecurityContextPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(PodSecurityContextPatchPtrOutput) } +func (i *podSecurityContextPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityContextPatch] { + return pulumix.Output[*PodSecurityContextPatch]{ + OutputState: i.ToPodSecurityContextPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext. type PodSecurityContextPatchOutput struct{ *pulumi.OutputState } @@ -43715,6 +49596,12 @@ func (o PodSecurityContextPatchOutput) ToPodSecurityContextPatchPtrOutputWithCon }).(PodSecurityContextPatchPtrOutput) } +func (o PodSecurityContextPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityContextPatch] { + return pulumix.Output[PodSecurityContextPatch]{ + OutputState: o.OutputState, + } +} + // A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: // // 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- @@ -43783,6 +49670,12 @@ func (o PodSecurityContextPatchPtrOutput) ToPodSecurityContextPatchPtrOutputWith return o } +func (o PodSecurityContextPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityContextPatch] { + return pulumix.Output[*PodSecurityContextPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityContextPatchPtrOutput) Elem() PodSecurityContextPatchOutput { return o.ApplyT(func(v *PodSecurityContextPatch) PodSecurityContextPatch { if v != nil { @@ -44108,6 +50001,12 @@ func (i PodSpecArgs) ToPodSpecOutputWithContext(ctx context.Context) PodSpecOutp return pulumi.ToOutputWithContext(ctx, i).(PodSpecOutput) } +func (i PodSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodSpec] { + return pulumix.Output[PodSpec]{ + OutputState: i.ToPodSpecOutputWithContext(ctx).OutputState, + } +} + func (i PodSpecArgs) ToPodSpecPtrOutput() PodSpecPtrOutput { return i.ToPodSpecPtrOutputWithContext(context.Background()) } @@ -44149,6 +50048,12 @@ func (i *podSpecPtrType) ToPodSpecPtrOutputWithContext(ctx context.Context) PodS return pulumi.ToOutputWithContext(ctx, i).(PodSpecPtrOutput) } +func (i *podSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSpec] { + return pulumix.Output[*PodSpec]{ + OutputState: i.ToPodSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodSpec is a description of a pod. type PodSpecOutput struct{ *pulumi.OutputState } @@ -44174,6 +50079,12 @@ func (o PodSpecOutput) ToPodSpecPtrOutputWithContext(ctx context.Context) PodSpe }).(PodSpecPtrOutput) } +func (o PodSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodSpec] { + return pulumix.Output[PodSpec]{ + OutputState: o.OutputState, + } +} + // Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer. func (o PodSpecOutput) ActiveDeadlineSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v PodSpec) *int { return v.ActiveDeadlineSeconds }).(pulumi.IntPtrOutput) @@ -44395,6 +50306,12 @@ func (o PodSpecPtrOutput) ToPodSpecPtrOutputWithContext(ctx context.Context) Pod return o } +func (o PodSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSpec] { + return pulumix.Output[*PodSpec]{ + OutputState: o.OutputState, + } +} + func (o PodSpecPtrOutput) Elem() PodSpecOutput { return o.ApplyT(func(v *PodSpec) PodSpec { if v != nil { @@ -45018,6 +50935,12 @@ func (i PodSpecPatchArgs) ToPodSpecPatchOutputWithContext(ctx context.Context) P return pulumi.ToOutputWithContext(ctx, i).(PodSpecPatchOutput) } +func (i PodSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSpecPatch] { + return pulumix.Output[PodSpecPatch]{ + OutputState: i.ToPodSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSpecPatchArgs) ToPodSpecPatchPtrOutput() PodSpecPatchPtrOutput { return i.ToPodSpecPatchPtrOutputWithContext(context.Background()) } @@ -45059,6 +50982,12 @@ func (i *podSpecPatchPtrType) ToPodSpecPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PodSpecPatchPtrOutput) } +func (i *podSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSpecPatch] { + return pulumix.Output[*PodSpecPatch]{ + OutputState: i.ToPodSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSpec is a description of a pod. type PodSpecPatchOutput struct{ *pulumi.OutputState } @@ -45084,6 +51013,12 @@ func (o PodSpecPatchOutput) ToPodSpecPatchPtrOutputWithContext(ctx context.Conte }).(PodSpecPatchPtrOutput) } +func (o PodSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSpecPatch] { + return pulumix.Output[PodSpecPatch]{ + OutputState: o.OutputState, + } +} + // Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer. func (o PodSpecPatchOutput) ActiveDeadlineSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v PodSpecPatch) *int { return v.ActiveDeadlineSeconds }).(pulumi.IntPtrOutput) @@ -45305,6 +51240,12 @@ func (o PodSpecPatchPtrOutput) ToPodSpecPatchPtrOutputWithContext(ctx context.Co return o } +func (o PodSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSpecPatch] { + return pulumix.Output[*PodSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSpecPatchPtrOutput) Elem() PodSpecPatchOutput { return o.ApplyT(func(v *PodSpecPatch) PodSpecPatch { if v != nil { @@ -45820,6 +51761,12 @@ func (i PodStatusArgs) ToPodStatusOutputWithContext(ctx context.Context) PodStat return pulumi.ToOutputWithContext(ctx, i).(PodStatusOutput) } +func (i PodStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodStatus] { + return pulumix.Output[PodStatus]{ + OutputState: i.ToPodStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodStatusArgs) ToPodStatusPtrOutput() PodStatusPtrOutput { return i.ToPodStatusPtrOutputWithContext(context.Background()) } @@ -45861,6 +51808,12 @@ func (i *podStatusPtrType) ToPodStatusPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PodStatusPtrOutput) } +func (i *podStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodStatus] { + return pulumix.Output[*PodStatus]{ + OutputState: i.ToPodStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane. type PodStatusOutput struct{ *pulumi.OutputState } @@ -45886,6 +51839,12 @@ func (o PodStatusOutput) ToPodStatusPtrOutputWithContext(ctx context.Context) Po }).(PodStatusPtrOutput) } +func (o PodStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodStatus] { + return pulumix.Output[PodStatus]{ + OutputState: o.OutputState, + } +} + // Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions func (o PodStatusOutput) Conditions() PodConditionArrayOutput { return o.ApplyT(func(v PodStatus) []PodCondition { return v.Conditions }).(PodConditionArrayOutput) @@ -45984,6 +51943,12 @@ func (o PodStatusPtrOutput) ToPodStatusPtrOutputWithContext(ctx context.Context) return o } +func (o PodStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodStatus] { + return pulumix.Output[*PodStatus]{ + OutputState: o.OutputState, + } +} + func (o PodStatusPtrOutput) Elem() PodStatusOutput { return o.ApplyT(func(v *PodStatus) PodStatus { if v != nil { @@ -46261,6 +52226,12 @@ func (i PodStatusPatchArgs) ToPodStatusPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PodStatusPatchOutput) } +func (i PodStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodStatusPatch] { + return pulumix.Output[PodStatusPatch]{ + OutputState: i.ToPodStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodStatusPatchArgs) ToPodStatusPatchPtrOutput() PodStatusPatchPtrOutput { return i.ToPodStatusPatchPtrOutputWithContext(context.Background()) } @@ -46302,6 +52273,12 @@ func (i *podStatusPatchPtrType) ToPodStatusPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(PodStatusPatchPtrOutput) } +func (i *podStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodStatusPatch] { + return pulumix.Output[*PodStatusPatch]{ + OutputState: i.ToPodStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane. type PodStatusPatchOutput struct{ *pulumi.OutputState } @@ -46327,6 +52304,12 @@ func (o PodStatusPatchOutput) ToPodStatusPatchPtrOutputWithContext(ctx context.C }).(PodStatusPatchPtrOutput) } +func (o PodStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodStatusPatch] { + return pulumix.Output[PodStatusPatch]{ + OutputState: o.OutputState, + } +} + // Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions func (o PodStatusPatchOutput) Conditions() PodConditionPatchArrayOutput { return o.ApplyT(func(v PodStatusPatch) []PodConditionPatch { return v.Conditions }).(PodConditionPatchArrayOutput) @@ -46425,6 +52408,12 @@ func (o PodStatusPatchPtrOutput) ToPodStatusPatchPtrOutputWithContext(ctx contex return o } +func (o PodStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodStatusPatch] { + return pulumix.Output[*PodStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodStatusPatchPtrOutput) Elem() PodStatusPatchOutput { return o.ApplyT(func(v *PodStatusPatch) PodStatusPatch { if v != nil { @@ -46646,6 +52635,12 @@ func (i PodTemplateTypeArgs) ToPodTemplateTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PodTemplateTypeOutput) } +func (i PodTemplateTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodTemplateType] { + return pulumix.Output[PodTemplateType]{ + OutputState: i.ToPodTemplateTypeOutputWithContext(ctx).OutputState, + } +} + // PodTemplateTypeArrayInput is an input type that accepts PodTemplateTypeArray and PodTemplateTypeArrayOutput values. // You can construct a concrete instance of `PodTemplateTypeArrayInput` via: // @@ -46671,6 +52666,12 @@ func (i PodTemplateTypeArray) ToPodTemplateTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodTemplateTypeArrayOutput) } +func (i PodTemplateTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodTemplateType] { + return pulumix.Output[[]PodTemplateType]{ + OutputState: i.ToPodTemplateTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodTemplate describes a template for creating copies of a predefined pod. type PodTemplateTypeOutput struct{ *pulumi.OutputState } @@ -46686,6 +52687,12 @@ func (o PodTemplateTypeOutput) ToPodTemplateTypeOutputWithContext(ctx context.Co return o } +func (o PodTemplateTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodTemplateType] { + return pulumix.Output[PodTemplateType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTemplateTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodTemplateType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -46720,6 +52727,12 @@ func (o PodTemplateTypeArrayOutput) ToPodTemplateTypeArrayOutputWithContext(ctx return o } +func (o PodTemplateTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodTemplateType] { + return pulumix.Output[[]PodTemplateType]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateTypeArrayOutput) Index(i pulumi.IntInput) PodTemplateTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodTemplateType { return vs[0].([]PodTemplateType)[vs[1].(int)] @@ -46773,6 +52786,12 @@ func (i PodTemplateListTypeArgs) ToPodTemplateListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PodTemplateListTypeOutput) } +func (i PodTemplateListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodTemplateListType] { + return pulumix.Output[PodTemplateListType]{ + OutputState: i.ToPodTemplateListTypeOutputWithContext(ctx).OutputState, + } +} + // PodTemplateList is a list of PodTemplates. type PodTemplateListTypeOutput struct{ *pulumi.OutputState } @@ -46788,6 +52807,12 @@ func (o PodTemplateListTypeOutput) ToPodTemplateListTypeOutputWithContext(ctx co return o } +func (o PodTemplateListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodTemplateListType] { + return pulumix.Output[PodTemplateListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTemplateListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodTemplateListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -46855,6 +52880,12 @@ func (i PodTemplatePatchTypeArgs) ToPodTemplatePatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodTemplatePatchTypeOutput) } +func (i PodTemplatePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodTemplatePatchType] { + return pulumix.Output[PodTemplatePatchType]{ + OutputState: i.ToPodTemplatePatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodTemplate describes a template for creating copies of a predefined pod. type PodTemplatePatchTypeOutput struct{ *pulumi.OutputState } @@ -46870,6 +52901,12 @@ func (o PodTemplatePatchTypeOutput) ToPodTemplatePatchTypeOutputWithContext(ctx return o } +func (o PodTemplatePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodTemplatePatchType] { + return pulumix.Output[PodTemplatePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodTemplatePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodTemplatePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -46929,6 +52966,12 @@ func (i PodTemplateSpecArgs) ToPodTemplateSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PodTemplateSpecOutput) } +func (i PodTemplateSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodTemplateSpec] { + return pulumix.Output[PodTemplateSpec]{ + OutputState: i.ToPodTemplateSpecOutputWithContext(ctx).OutputState, + } +} + func (i PodTemplateSpecArgs) ToPodTemplateSpecPtrOutput() PodTemplateSpecPtrOutput { return i.ToPodTemplateSpecPtrOutputWithContext(context.Background()) } @@ -46970,6 +53013,12 @@ func (i *podTemplateSpecPtrType) ToPodTemplateSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(PodTemplateSpecPtrOutput) } +func (i *podTemplateSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodTemplateSpec] { + return pulumix.Output[*PodTemplateSpec]{ + OutputState: i.ToPodTemplateSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodTemplateSpec describes the data a pod should have when created from a template type PodTemplateSpecOutput struct{ *pulumi.OutputState } @@ -46995,6 +53044,12 @@ func (o PodTemplateSpecOutput) ToPodTemplateSpecPtrOutputWithContext(ctx context }).(PodTemplateSpecPtrOutput) } +func (o PodTemplateSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodTemplateSpec] { + return pulumix.Output[PodTemplateSpec]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o PodTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v PodTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -47019,6 +53074,12 @@ func (o PodTemplateSpecPtrOutput) ToPodTemplateSpecPtrOutputWithContext(ctx cont return o } +func (o PodTemplateSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodTemplateSpec] { + return pulumix.Output[*PodTemplateSpec]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateSpecPtrOutput) Elem() PodTemplateSpecOutput { return o.ApplyT(func(v *PodTemplateSpec) PodTemplateSpec { if v != nil { @@ -47088,6 +53149,12 @@ func (i PodTemplateSpecPatchArgs) ToPodTemplateSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodTemplateSpecPatchOutput) } +func (i PodTemplateSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodTemplateSpecPatch] { + return pulumix.Output[PodTemplateSpecPatch]{ + OutputState: i.ToPodTemplateSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodTemplateSpecPatchArgs) ToPodTemplateSpecPatchPtrOutput() PodTemplateSpecPatchPtrOutput { return i.ToPodTemplateSpecPatchPtrOutputWithContext(context.Background()) } @@ -47129,6 +53196,12 @@ func (i *podTemplateSpecPatchPtrType) ToPodTemplateSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PodTemplateSpecPatchPtrOutput) } +func (i *podTemplateSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodTemplateSpecPatch] { + return pulumix.Output[*PodTemplateSpecPatch]{ + OutputState: i.ToPodTemplateSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodTemplateSpec describes the data a pod should have when created from a template type PodTemplateSpecPatchOutput struct{ *pulumi.OutputState } @@ -47154,6 +53227,12 @@ func (o PodTemplateSpecPatchOutput) ToPodTemplateSpecPatchPtrOutputWithContext(c }).(PodTemplateSpecPatchPtrOutput) } +func (o PodTemplateSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodTemplateSpecPatch] { + return pulumix.Output[PodTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata func (o PodTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v PodTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -47178,6 +53257,12 @@ func (o PodTemplateSpecPatchPtrOutput) ToPodTemplateSpecPatchPtrOutputWithContex return o } +func (o PodTemplateSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodTemplateSpecPatch] { + return pulumix.Output[*PodTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodTemplateSpecPatchPtrOutput) Elem() PodTemplateSpecPatchOutput { return o.ApplyT(func(v *PodTemplateSpecPatch) PodTemplateSpecPatch { if v != nil { @@ -47255,6 +53340,12 @@ func (i PortStatusArgs) ToPortStatusOutputWithContext(ctx context.Context) PortS return pulumi.ToOutputWithContext(ctx, i).(PortStatusOutput) } +func (i PortStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PortStatus] { + return pulumix.Output[PortStatus]{ + OutputState: i.ToPortStatusOutputWithContext(ctx).OutputState, + } +} + // PortStatusArrayInput is an input type that accepts PortStatusArray and PortStatusArrayOutput values. // You can construct a concrete instance of `PortStatusArrayInput` via: // @@ -47280,6 +53371,12 @@ func (i PortStatusArray) ToPortStatusArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PortStatusArrayOutput) } +func (i PortStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]PortStatus] { + return pulumix.Output[[]PortStatus]{ + OutputState: i.ToPortStatusArrayOutputWithContext(ctx).OutputState, + } +} + type PortStatusOutput struct{ *pulumi.OutputState } func (PortStatusOutput) ElementType() reflect.Type { @@ -47294,6 +53391,12 @@ func (o PortStatusOutput) ToPortStatusOutputWithContext(ctx context.Context) Por return o } +func (o PortStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PortStatus] { + return pulumix.Output[PortStatus]{ + OutputState: o.OutputState, + } +} + // Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use // // CamelCase names @@ -47327,6 +53430,12 @@ func (o PortStatusArrayOutput) ToPortStatusArrayOutputWithContext(ctx context.Co return o } +func (o PortStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PortStatus] { + return pulumix.Output[[]PortStatus]{ + OutputState: o.OutputState, + } +} + func (o PortStatusArrayOutput) Index(i pulumi.IntInput) PortStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PortStatus { return vs[0].([]PortStatus)[vs[1].(int)] @@ -47380,6 +53489,12 @@ func (i PortStatusPatchArgs) ToPortStatusPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PortStatusPatchOutput) } +func (i PortStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PortStatusPatch] { + return pulumix.Output[PortStatusPatch]{ + OutputState: i.ToPortStatusPatchOutputWithContext(ctx).OutputState, + } +} + // PortStatusPatchArrayInput is an input type that accepts PortStatusPatchArray and PortStatusPatchArrayOutput values. // You can construct a concrete instance of `PortStatusPatchArrayInput` via: // @@ -47405,6 +53520,12 @@ func (i PortStatusPatchArray) ToPortStatusPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PortStatusPatchArrayOutput) } +func (i PortStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PortStatusPatch] { + return pulumix.Output[[]PortStatusPatch]{ + OutputState: i.ToPortStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + type PortStatusPatchOutput struct{ *pulumi.OutputState } func (PortStatusPatchOutput) ElementType() reflect.Type { @@ -47419,6 +53540,12 @@ func (o PortStatusPatchOutput) ToPortStatusPatchOutputWithContext(ctx context.Co return o } +func (o PortStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PortStatusPatch] { + return pulumix.Output[PortStatusPatch]{ + OutputState: o.OutputState, + } +} + // Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use // // CamelCase names @@ -47452,6 +53579,12 @@ func (o PortStatusPatchArrayOutput) ToPortStatusPatchArrayOutputWithContext(ctx return o } +func (o PortStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PortStatusPatch] { + return pulumix.Output[[]PortStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PortStatusPatchArrayOutput) Index(i pulumi.IntInput) PortStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PortStatusPatch { return vs[0].([]PortStatusPatch)[vs[1].(int)] @@ -47501,6 +53634,12 @@ func (i PortworxVolumeSourceArgs) ToPortworxVolumeSourceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PortworxVolumeSourceOutput) } +func (i PortworxVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[PortworxVolumeSource] { + return pulumix.Output[PortworxVolumeSource]{ + OutputState: i.ToPortworxVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i PortworxVolumeSourceArgs) ToPortworxVolumeSourcePtrOutput() PortworxVolumeSourcePtrOutput { return i.ToPortworxVolumeSourcePtrOutputWithContext(context.Background()) } @@ -47542,6 +53681,12 @@ func (i *portworxVolumeSourcePtrType) ToPortworxVolumeSourcePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PortworxVolumeSourcePtrOutput) } +func (i *portworxVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*PortworxVolumeSource] { + return pulumix.Output[*PortworxVolumeSource]{ + OutputState: i.ToPortworxVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // PortworxVolumeSource represents a Portworx volume resource. type PortworxVolumeSourceOutput struct{ *pulumi.OutputState } @@ -47567,6 +53712,12 @@ func (o PortworxVolumeSourceOutput) ToPortworxVolumeSourcePtrOutputWithContext(c }).(PortworxVolumeSourcePtrOutput) } +func (o PortworxVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[PortworxVolumeSource] { + return pulumix.Output[PortworxVolumeSource]{ + OutputState: o.OutputState, + } +} + // fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs". Implicitly inferred to be "ext4" if unspecified. func (o PortworxVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v PortworxVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -47596,6 +53747,12 @@ func (o PortworxVolumeSourcePtrOutput) ToPortworxVolumeSourcePtrOutputWithContex return o } +func (o PortworxVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PortworxVolumeSource] { + return pulumix.Output[*PortworxVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o PortworxVolumeSourcePtrOutput) Elem() PortworxVolumeSourceOutput { return o.ApplyT(func(v *PortworxVolumeSource) PortworxVolumeSource { if v != nil { @@ -47679,6 +53836,12 @@ func (i PortworxVolumeSourcePatchArgs) ToPortworxVolumeSourcePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PortworxVolumeSourcePatchOutput) } +func (i PortworxVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PortworxVolumeSourcePatch] { + return pulumix.Output[PortworxVolumeSourcePatch]{ + OutputState: i.ToPortworxVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i PortworxVolumeSourcePatchArgs) ToPortworxVolumeSourcePatchPtrOutput() PortworxVolumeSourcePatchPtrOutput { return i.ToPortworxVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -47720,6 +53883,12 @@ func (i *portworxVolumeSourcePatchPtrType) ToPortworxVolumeSourcePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(PortworxVolumeSourcePatchPtrOutput) } +func (i *portworxVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PortworxVolumeSourcePatch] { + return pulumix.Output[*PortworxVolumeSourcePatch]{ + OutputState: i.ToPortworxVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PortworxVolumeSource represents a Portworx volume resource. type PortworxVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -47745,6 +53914,12 @@ func (o PortworxVolumeSourcePatchOutput) ToPortworxVolumeSourcePatchPtrOutputWit }).(PortworxVolumeSourcePatchPtrOutput) } +func (o PortworxVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PortworxVolumeSourcePatch] { + return pulumix.Output[PortworxVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs". Implicitly inferred to be "ext4" if unspecified. func (o PortworxVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v PortworxVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -47774,6 +53949,12 @@ func (o PortworxVolumeSourcePatchPtrOutput) ToPortworxVolumeSourcePatchPtrOutput return o } +func (o PortworxVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PortworxVolumeSourcePatch] { + return pulumix.Output[*PortworxVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o PortworxVolumeSourcePatchPtrOutput) Elem() PortworxVolumeSourcePatchOutput { return o.ApplyT(func(v *PortworxVolumeSourcePatch) PortworxVolumeSourcePatch { if v != nil { @@ -47853,6 +54034,12 @@ func (i PreferredSchedulingTermArgs) ToPreferredSchedulingTermOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PreferredSchedulingTermOutput) } +func (i PreferredSchedulingTermArgs) ToOutput(ctx context.Context) pulumix.Output[PreferredSchedulingTerm] { + return pulumix.Output[PreferredSchedulingTerm]{ + OutputState: i.ToPreferredSchedulingTermOutputWithContext(ctx).OutputState, + } +} + // PreferredSchedulingTermArrayInput is an input type that accepts PreferredSchedulingTermArray and PreferredSchedulingTermArrayOutput values. // You can construct a concrete instance of `PreferredSchedulingTermArrayInput` via: // @@ -47878,6 +54065,12 @@ func (i PreferredSchedulingTermArray) ToPreferredSchedulingTermArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PreferredSchedulingTermArrayOutput) } +func (i PreferredSchedulingTermArray) ToOutput(ctx context.Context) pulumix.Output[[]PreferredSchedulingTerm] { + return pulumix.Output[[]PreferredSchedulingTerm]{ + OutputState: i.ToPreferredSchedulingTermArrayOutputWithContext(ctx).OutputState, + } +} + // An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). type PreferredSchedulingTermOutput struct{ *pulumi.OutputState } @@ -47893,6 +54086,12 @@ func (o PreferredSchedulingTermOutput) ToPreferredSchedulingTermOutputWithContex return o } +func (o PreferredSchedulingTermOutput) ToOutput(ctx context.Context) pulumix.Output[PreferredSchedulingTerm] { + return pulumix.Output[PreferredSchedulingTerm]{ + OutputState: o.OutputState, + } +} + // A node selector term, associated with the corresponding weight. func (o PreferredSchedulingTermOutput) Preference() NodeSelectorTermOutput { return o.ApplyT(func(v PreferredSchedulingTerm) NodeSelectorTerm { return v.Preference }).(NodeSelectorTermOutput) @@ -47917,6 +54116,12 @@ func (o PreferredSchedulingTermArrayOutput) ToPreferredSchedulingTermArrayOutput return o } +func (o PreferredSchedulingTermArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PreferredSchedulingTerm] { + return pulumix.Output[[]PreferredSchedulingTerm]{ + OutputState: o.OutputState, + } +} + func (o PreferredSchedulingTermArrayOutput) Index(i pulumi.IntInput) PreferredSchedulingTermOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PreferredSchedulingTerm { return vs[0].([]PreferredSchedulingTerm)[vs[1].(int)] @@ -47962,6 +54167,12 @@ func (i PreferredSchedulingTermPatchArgs) ToPreferredSchedulingTermPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PreferredSchedulingTermPatchOutput) } +func (i PreferredSchedulingTermPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PreferredSchedulingTermPatch] { + return pulumix.Output[PreferredSchedulingTermPatch]{ + OutputState: i.ToPreferredSchedulingTermPatchOutputWithContext(ctx).OutputState, + } +} + // PreferredSchedulingTermPatchArrayInput is an input type that accepts PreferredSchedulingTermPatchArray and PreferredSchedulingTermPatchArrayOutput values. // You can construct a concrete instance of `PreferredSchedulingTermPatchArrayInput` via: // @@ -47987,6 +54198,12 @@ func (i PreferredSchedulingTermPatchArray) ToPreferredSchedulingTermPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(PreferredSchedulingTermPatchArrayOutput) } +func (i PreferredSchedulingTermPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PreferredSchedulingTermPatch] { + return pulumix.Output[[]PreferredSchedulingTermPatch]{ + OutputState: i.ToPreferredSchedulingTermPatchArrayOutputWithContext(ctx).OutputState, + } +} + // An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). type PreferredSchedulingTermPatchOutput struct{ *pulumi.OutputState } @@ -48002,6 +54219,12 @@ func (o PreferredSchedulingTermPatchOutput) ToPreferredSchedulingTermPatchOutput return o } +func (o PreferredSchedulingTermPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PreferredSchedulingTermPatch] { + return pulumix.Output[PreferredSchedulingTermPatch]{ + OutputState: o.OutputState, + } +} + // A node selector term, associated with the corresponding weight. func (o PreferredSchedulingTermPatchOutput) Preference() NodeSelectorTermPatchPtrOutput { return o.ApplyT(func(v PreferredSchedulingTermPatch) *NodeSelectorTermPatch { return v.Preference }).(NodeSelectorTermPatchPtrOutput) @@ -48026,6 +54249,12 @@ func (o PreferredSchedulingTermPatchArrayOutput) ToPreferredSchedulingTermPatchA return o } +func (o PreferredSchedulingTermPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PreferredSchedulingTermPatch] { + return pulumix.Output[[]PreferredSchedulingTermPatch]{ + OutputState: o.OutputState, + } +} + func (o PreferredSchedulingTermPatchArrayOutput) Index(i pulumi.IntInput) PreferredSchedulingTermPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PreferredSchedulingTermPatch { return vs[0].([]PreferredSchedulingTermPatch)[vs[1].(int)] @@ -48103,6 +54332,12 @@ func (i ProbeArgs) ToProbeOutputWithContext(ctx context.Context) ProbeOutput { return pulumi.ToOutputWithContext(ctx, i).(ProbeOutput) } +func (i ProbeArgs) ToOutput(ctx context.Context) pulumix.Output[Probe] { + return pulumix.Output[Probe]{ + OutputState: i.ToProbeOutputWithContext(ctx).OutputState, + } +} + func (i ProbeArgs) ToProbePtrOutput() ProbePtrOutput { return i.ToProbePtrOutputWithContext(context.Background()) } @@ -48144,6 +54379,12 @@ func (i *probePtrType) ToProbePtrOutputWithContext(ctx context.Context) ProbePtr return pulumi.ToOutputWithContext(ctx, i).(ProbePtrOutput) } +func (i *probePtrType) ToOutput(ctx context.Context) pulumix.Output[*Probe] { + return pulumix.Output[*Probe]{ + OutputState: i.ToProbePtrOutputWithContext(ctx).OutputState, + } +} + // Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic. type ProbeOutput struct{ *pulumi.OutputState } @@ -48169,6 +54410,12 @@ func (o ProbeOutput) ToProbePtrOutputWithContext(ctx context.Context) ProbePtrOu }).(ProbePtrOutput) } +func (o ProbeOutput) ToOutput(ctx context.Context) pulumix.Output[Probe] { + return pulumix.Output[Probe]{ + OutputState: o.OutputState, + } +} + // Exec specifies the action to take. func (o ProbeOutput) Exec() ExecActionPtrOutput { return o.ApplyT(func(v Probe) *ExecAction { return v.Exec }).(ExecActionPtrOutput) @@ -48233,6 +54480,12 @@ func (o ProbePtrOutput) ToProbePtrOutputWithContext(ctx context.Context) ProbePt return o } +func (o ProbePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Probe] { + return pulumix.Output[*Probe]{ + OutputState: o.OutputState, + } +} + func (o ProbePtrOutput) Elem() ProbeOutput { return o.ApplyT(func(v *Probe) Probe { if v != nil { @@ -48414,6 +54667,12 @@ func (i ProbePatchArgs) ToProbePatchOutputWithContext(ctx context.Context) Probe return pulumi.ToOutputWithContext(ctx, i).(ProbePatchOutput) } +func (i ProbePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ProbePatch] { + return pulumix.Output[ProbePatch]{ + OutputState: i.ToProbePatchOutputWithContext(ctx).OutputState, + } +} + func (i ProbePatchArgs) ToProbePatchPtrOutput() ProbePatchPtrOutput { return i.ToProbePatchPtrOutputWithContext(context.Background()) } @@ -48455,6 +54714,12 @@ func (i *probePatchPtrType) ToProbePatchPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ProbePatchPtrOutput) } +func (i *probePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ProbePatch] { + return pulumix.Output[*ProbePatch]{ + OutputState: i.ToProbePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic. type ProbePatchOutput struct{ *pulumi.OutputState } @@ -48480,6 +54745,12 @@ func (o ProbePatchOutput) ToProbePatchPtrOutputWithContext(ctx context.Context) }).(ProbePatchPtrOutput) } +func (o ProbePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ProbePatch] { + return pulumix.Output[ProbePatch]{ + OutputState: o.OutputState, + } +} + // Exec specifies the action to take. func (o ProbePatchOutput) Exec() ExecActionPatchPtrOutput { return o.ApplyT(func(v ProbePatch) *ExecActionPatch { return v.Exec }).(ExecActionPatchPtrOutput) @@ -48544,6 +54815,12 @@ func (o ProbePatchPtrOutput) ToProbePatchPtrOutputWithContext(ctx context.Contex return o } +func (o ProbePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ProbePatch] { + return pulumix.Output[*ProbePatch]{ + OutputState: o.OutputState, + } +} + func (o ProbePatchPtrOutput) Elem() ProbePatchOutput { return o.ApplyT(func(v *ProbePatch) ProbePatch { if v != nil { @@ -48693,6 +54970,12 @@ func (i ProjectedVolumeSourceArgs) ToProjectedVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ProjectedVolumeSourceOutput) } +func (i ProjectedVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ProjectedVolumeSource] { + return pulumix.Output[ProjectedVolumeSource]{ + OutputState: i.ToProjectedVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i ProjectedVolumeSourceArgs) ToProjectedVolumeSourcePtrOutput() ProjectedVolumeSourcePtrOutput { return i.ToProjectedVolumeSourcePtrOutputWithContext(context.Background()) } @@ -48734,6 +55017,12 @@ func (i *projectedVolumeSourcePtrType) ToProjectedVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ProjectedVolumeSourcePtrOutput) } +func (i *projectedVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ProjectedVolumeSource] { + return pulumix.Output[*ProjectedVolumeSource]{ + OutputState: i.ToProjectedVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a projected volume source type ProjectedVolumeSourceOutput struct{ *pulumi.OutputState } @@ -48759,6 +55048,12 @@ func (o ProjectedVolumeSourceOutput) ToProjectedVolumeSourcePtrOutputWithContext }).(ProjectedVolumeSourcePtrOutput) } +func (o ProjectedVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ProjectedVolumeSource] { + return pulumix.Output[ProjectedVolumeSource]{ + OutputState: o.OutputState, + } +} + // defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o ProjectedVolumeSourceOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v ProjectedVolumeSource) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -48783,6 +55078,12 @@ func (o ProjectedVolumeSourcePtrOutput) ToProjectedVolumeSourcePtrOutputWithCont return o } +func (o ProjectedVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ProjectedVolumeSource] { + return pulumix.Output[*ProjectedVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o ProjectedVolumeSourcePtrOutput) Elem() ProjectedVolumeSourceOutput { return o.ApplyT(func(v *ProjectedVolumeSource) ProjectedVolumeSource { if v != nil { @@ -48852,6 +55153,12 @@ func (i ProjectedVolumeSourcePatchArgs) ToProjectedVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ProjectedVolumeSourcePatchOutput) } +func (i ProjectedVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ProjectedVolumeSourcePatch] { + return pulumix.Output[ProjectedVolumeSourcePatch]{ + OutputState: i.ToProjectedVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ProjectedVolumeSourcePatchArgs) ToProjectedVolumeSourcePatchPtrOutput() ProjectedVolumeSourcePatchPtrOutput { return i.ToProjectedVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -48893,6 +55200,12 @@ func (i *projectedVolumeSourcePatchPtrType) ToProjectedVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ProjectedVolumeSourcePatchPtrOutput) } +func (i *projectedVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ProjectedVolumeSourcePatch] { + return pulumix.Output[*ProjectedVolumeSourcePatch]{ + OutputState: i.ToProjectedVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a projected volume source type ProjectedVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -48918,6 +55231,12 @@ func (o ProjectedVolumeSourcePatchOutput) ToProjectedVolumeSourcePatchPtrOutputW }).(ProjectedVolumeSourcePatchPtrOutput) } +func (o ProjectedVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ProjectedVolumeSourcePatch] { + return pulumix.Output[ProjectedVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o ProjectedVolumeSourcePatchOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v ProjectedVolumeSourcePatch) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -48942,6 +55261,12 @@ func (o ProjectedVolumeSourcePatchPtrOutput) ToProjectedVolumeSourcePatchPtrOutp return o } +func (o ProjectedVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ProjectedVolumeSourcePatch] { + return pulumix.Output[*ProjectedVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ProjectedVolumeSourcePatchPtrOutput) Elem() ProjectedVolumeSourcePatchOutput { return o.ApplyT(func(v *ProjectedVolumeSourcePatch) ProjectedVolumeSourcePatch { if v != nil { @@ -49027,6 +55352,12 @@ func (i QuobyteVolumeSourceArgs) ToQuobyteVolumeSourceOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(QuobyteVolumeSourceOutput) } +func (i QuobyteVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[QuobyteVolumeSource] { + return pulumix.Output[QuobyteVolumeSource]{ + OutputState: i.ToQuobyteVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i QuobyteVolumeSourceArgs) ToQuobyteVolumeSourcePtrOutput() QuobyteVolumeSourcePtrOutput { return i.ToQuobyteVolumeSourcePtrOutputWithContext(context.Background()) } @@ -49068,6 +55399,12 @@ func (i *quobyteVolumeSourcePtrType) ToQuobyteVolumeSourcePtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(QuobyteVolumeSourcePtrOutput) } +func (i *quobyteVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*QuobyteVolumeSource] { + return pulumix.Output[*QuobyteVolumeSource]{ + OutputState: i.ToQuobyteVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling. type QuobyteVolumeSourceOutput struct{ *pulumi.OutputState } @@ -49093,6 +55430,12 @@ func (o QuobyteVolumeSourceOutput) ToQuobyteVolumeSourcePtrOutputWithContext(ctx }).(QuobyteVolumeSourcePtrOutput) } +func (o QuobyteVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[QuobyteVolumeSource] { + return pulumix.Output[QuobyteVolumeSource]{ + OutputState: o.OutputState, + } +} + // group to map volume access to Default is no group func (o QuobyteVolumeSourceOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v QuobyteVolumeSource) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -49137,6 +55480,12 @@ func (o QuobyteVolumeSourcePtrOutput) ToQuobyteVolumeSourcePtrOutputWithContext( return o } +func (o QuobyteVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QuobyteVolumeSource] { + return pulumix.Output[*QuobyteVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o QuobyteVolumeSourcePtrOutput) Elem() QuobyteVolumeSourceOutput { return o.ApplyT(func(v *QuobyteVolumeSource) QuobyteVolumeSource { if v != nil { @@ -49262,6 +55611,12 @@ func (i QuobyteVolumeSourcePatchArgs) ToQuobyteVolumeSourcePatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(QuobyteVolumeSourcePatchOutput) } +func (i QuobyteVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[QuobyteVolumeSourcePatch] { + return pulumix.Output[QuobyteVolumeSourcePatch]{ + OutputState: i.ToQuobyteVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i QuobyteVolumeSourcePatchArgs) ToQuobyteVolumeSourcePatchPtrOutput() QuobyteVolumeSourcePatchPtrOutput { return i.ToQuobyteVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -49303,6 +55658,12 @@ func (i *quobyteVolumeSourcePatchPtrType) ToQuobyteVolumeSourcePatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(QuobyteVolumeSourcePatchPtrOutput) } +func (i *quobyteVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*QuobyteVolumeSourcePatch] { + return pulumix.Output[*QuobyteVolumeSourcePatch]{ + OutputState: i.ToQuobyteVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling. type QuobyteVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -49328,6 +55689,12 @@ func (o QuobyteVolumeSourcePatchOutput) ToQuobyteVolumeSourcePatchPtrOutputWithC }).(QuobyteVolumeSourcePatchPtrOutput) } +func (o QuobyteVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[QuobyteVolumeSourcePatch] { + return pulumix.Output[QuobyteVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // group to map volume access to Default is no group func (o QuobyteVolumeSourcePatchOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v QuobyteVolumeSourcePatch) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -49372,6 +55739,12 @@ func (o QuobyteVolumeSourcePatchPtrOutput) ToQuobyteVolumeSourcePatchPtrOutputWi return o } +func (o QuobyteVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QuobyteVolumeSourcePatch] { + return pulumix.Output[*QuobyteVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o QuobyteVolumeSourcePatchPtrOutput) Elem() QuobyteVolumeSourcePatchOutput { return o.ApplyT(func(v *QuobyteVolumeSourcePatch) QuobyteVolumeSourcePatch { if v != nil { @@ -49505,6 +55878,12 @@ func (i RBDPersistentVolumeSourceArgs) ToRBDPersistentVolumeSourceOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(RBDPersistentVolumeSourceOutput) } +func (i RBDPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[RBDPersistentVolumeSource] { + return pulumix.Output[RBDPersistentVolumeSource]{ + OutputState: i.ToRBDPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i RBDPersistentVolumeSourceArgs) ToRBDPersistentVolumeSourcePtrOutput() RBDPersistentVolumeSourcePtrOutput { return i.ToRBDPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -49546,6 +55925,12 @@ func (i *rbdpersistentVolumeSourcePtrType) ToRBDPersistentVolumeSourcePtrOutputW return pulumi.ToOutputWithContext(ctx, i).(RBDPersistentVolumeSourcePtrOutput) } +func (i *rbdpersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*RBDPersistentVolumeSource] { + return pulumix.Output[*RBDPersistentVolumeSource]{ + OutputState: i.ToRBDPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. type RBDPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -49571,6 +55956,12 @@ func (o RBDPersistentVolumeSourceOutput) ToRBDPersistentVolumeSourcePtrOutputWit }).(RBDPersistentVolumeSourcePtrOutput) } +func (o RBDPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[RBDPersistentVolumeSource] { + return pulumix.Output[RBDPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd func (o RBDPersistentVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v RBDPersistentVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -49625,6 +56016,12 @@ func (o RBDPersistentVolumeSourcePtrOutput) ToRBDPersistentVolumeSourcePtrOutput return o } +func (o RBDPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RBDPersistentVolumeSource] { + return pulumix.Output[*RBDPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o RBDPersistentVolumeSourcePtrOutput) Elem() RBDPersistentVolumeSourceOutput { return o.ApplyT(func(v *RBDPersistentVolumeSource) RBDPersistentVolumeSource { if v != nil { @@ -49778,6 +56175,12 @@ func (i RBDPersistentVolumeSourcePatchArgs) ToRBDPersistentVolumeSourcePatchOutp return pulumi.ToOutputWithContext(ctx, i).(RBDPersistentVolumeSourcePatchOutput) } +func (i RBDPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[RBDPersistentVolumeSourcePatch] { + return pulumix.Output[RBDPersistentVolumeSourcePatch]{ + OutputState: i.ToRBDPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i RBDPersistentVolumeSourcePatchArgs) ToRBDPersistentVolumeSourcePatchPtrOutput() RBDPersistentVolumeSourcePatchPtrOutput { return i.ToRBDPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -49819,6 +56222,12 @@ func (i *rbdpersistentVolumeSourcePatchPtrType) ToRBDPersistentVolumeSourcePatch return pulumi.ToOutputWithContext(ctx, i).(RBDPersistentVolumeSourcePatchPtrOutput) } +func (i *rbdpersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RBDPersistentVolumeSourcePatch] { + return pulumix.Output[*RBDPersistentVolumeSourcePatch]{ + OutputState: i.ToRBDPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. type RBDPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -49844,6 +56253,12 @@ func (o RBDPersistentVolumeSourcePatchOutput) ToRBDPersistentVolumeSourcePatchPt }).(RBDPersistentVolumeSourcePatchPtrOutput) } +func (o RBDPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[RBDPersistentVolumeSourcePatch] { + return pulumix.Output[RBDPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd func (o RBDPersistentVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v RBDPersistentVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -49898,6 +56313,12 @@ func (o RBDPersistentVolumeSourcePatchPtrOutput) ToRBDPersistentVolumeSourcePatc return o } +func (o RBDPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RBDPersistentVolumeSourcePatch] { + return pulumix.Output[*RBDPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o RBDPersistentVolumeSourcePatchPtrOutput) Elem() RBDPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *RBDPersistentVolumeSourcePatch) RBDPersistentVolumeSourcePatch { if v != nil { @@ -50051,6 +56472,12 @@ func (i RBDVolumeSourceArgs) ToRBDVolumeSourceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RBDVolumeSourceOutput) } +func (i RBDVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[RBDVolumeSource] { + return pulumix.Output[RBDVolumeSource]{ + OutputState: i.ToRBDVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i RBDVolumeSourceArgs) ToRBDVolumeSourcePtrOutput() RBDVolumeSourcePtrOutput { return i.ToRBDVolumeSourcePtrOutputWithContext(context.Background()) } @@ -50092,6 +56519,12 @@ func (i *rbdvolumeSourcePtrType) ToRBDVolumeSourcePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(RBDVolumeSourcePtrOutput) } +func (i *rbdvolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*RBDVolumeSource] { + return pulumix.Output[*RBDVolumeSource]{ + OutputState: i.ToRBDVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. type RBDVolumeSourceOutput struct{ *pulumi.OutputState } @@ -50117,6 +56550,12 @@ func (o RBDVolumeSourceOutput) ToRBDVolumeSourcePtrOutputWithContext(ctx context }).(RBDVolumeSourcePtrOutput) } +func (o RBDVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[RBDVolumeSource] { + return pulumix.Output[RBDVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd func (o RBDVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v RBDVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -50171,6 +56610,12 @@ func (o RBDVolumeSourcePtrOutput) ToRBDVolumeSourcePtrOutputWithContext(ctx cont return o } +func (o RBDVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RBDVolumeSource] { + return pulumix.Output[*RBDVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o RBDVolumeSourcePtrOutput) Elem() RBDVolumeSourceOutput { return o.ApplyT(func(v *RBDVolumeSource) RBDVolumeSource { if v != nil { @@ -50324,6 +56769,12 @@ func (i RBDVolumeSourcePatchArgs) ToRBDVolumeSourcePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RBDVolumeSourcePatchOutput) } +func (i RBDVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[RBDVolumeSourcePatch] { + return pulumix.Output[RBDVolumeSourcePatch]{ + OutputState: i.ToRBDVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i RBDVolumeSourcePatchArgs) ToRBDVolumeSourcePatchPtrOutput() RBDVolumeSourcePatchPtrOutput { return i.ToRBDVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -50365,6 +56816,12 @@ func (i *rbdvolumeSourcePatchPtrType) ToRBDVolumeSourcePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(RBDVolumeSourcePatchPtrOutput) } +func (i *rbdvolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RBDVolumeSourcePatch] { + return pulumix.Output[*RBDVolumeSourcePatch]{ + OutputState: i.ToRBDVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. type RBDVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -50390,6 +56847,12 @@ func (o RBDVolumeSourcePatchOutput) ToRBDVolumeSourcePatchPtrOutputWithContext(c }).(RBDVolumeSourcePatchPtrOutput) } +func (o RBDVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[RBDVolumeSourcePatch] { + return pulumix.Output[RBDVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd func (o RBDVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v RBDVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -50444,6 +56907,12 @@ func (o RBDVolumeSourcePatchPtrOutput) ToRBDVolumeSourcePatchPtrOutputWithContex return o } +func (o RBDVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RBDVolumeSourcePatch] { + return pulumix.Output[*RBDVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o RBDVolumeSourcePatchPtrOutput) Elem() RBDVolumeSourcePatchOutput { return o.ApplyT(func(v *RBDVolumeSourcePatch) RBDVolumeSourcePatch { if v != nil { @@ -50585,6 +57054,12 @@ func (i ReplicationControllerTypeArgs) ToReplicationControllerTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerTypeOutput) } +func (i ReplicationControllerTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerType] { + return pulumix.Output[ReplicationControllerType]{ + OutputState: i.ToReplicationControllerTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerTypeArrayInput is an input type that accepts ReplicationControllerTypeArray and ReplicationControllerTypeArrayOutput values. // You can construct a concrete instance of `ReplicationControllerTypeArrayInput` via: // @@ -50610,6 +57085,12 @@ func (i ReplicationControllerTypeArray) ToReplicationControllerTypeArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerTypeArrayOutput) } +func (i ReplicationControllerTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicationControllerType] { + return pulumix.Output[[]ReplicationControllerType]{ + OutputState: i.ToReplicationControllerTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicationController represents the configuration of a replication controller. type ReplicationControllerTypeOutput struct{ *pulumi.OutputState } @@ -50625,6 +57106,12 @@ func (o ReplicationControllerTypeOutput) ToReplicationControllerTypeOutputWithCo return o } +func (o ReplicationControllerTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerType] { + return pulumix.Output[ReplicationControllerType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicationControllerTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicationControllerType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -50664,6 +57151,12 @@ func (o ReplicationControllerTypeArrayOutput) ToReplicationControllerTypeArrayOu return o } +func (o ReplicationControllerTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicationControllerType] { + return pulumix.Output[[]ReplicationControllerType]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerTypeArrayOutput) Index(i pulumi.IntInput) ReplicationControllerTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicationControllerType { return vs[0].([]ReplicationControllerType)[vs[1].(int)] @@ -50721,6 +57214,12 @@ func (i ReplicationControllerConditionArgs) ToReplicationControllerConditionOutp return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerConditionOutput) } +func (i ReplicationControllerConditionArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerCondition] { + return pulumix.Output[ReplicationControllerCondition]{ + OutputState: i.ToReplicationControllerConditionOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerConditionArrayInput is an input type that accepts ReplicationControllerConditionArray and ReplicationControllerConditionArrayOutput values. // You can construct a concrete instance of `ReplicationControllerConditionArrayInput` via: // @@ -50746,6 +57245,12 @@ func (i ReplicationControllerConditionArray) ToReplicationControllerConditionArr return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerConditionArrayOutput) } +func (i ReplicationControllerConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicationControllerCondition] { + return pulumix.Output[[]ReplicationControllerCondition]{ + OutputState: i.ToReplicationControllerConditionArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerCondition describes the state of a replication controller at a certain point. type ReplicationControllerConditionOutput struct{ *pulumi.OutputState } @@ -50761,6 +57266,12 @@ func (o ReplicationControllerConditionOutput) ToReplicationControllerConditionOu return o } +func (o ReplicationControllerConditionOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerCondition] { + return pulumix.Output[ReplicationControllerCondition]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicationControllerConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicationControllerCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -50800,6 +57311,12 @@ func (o ReplicationControllerConditionArrayOutput) ToReplicationControllerCondit return o } +func (o ReplicationControllerConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicationControllerCondition] { + return pulumix.Output[[]ReplicationControllerCondition]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerConditionArrayOutput) Index(i pulumi.IntInput) ReplicationControllerConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicationControllerCondition { return vs[0].([]ReplicationControllerCondition)[vs[1].(int)] @@ -50857,6 +57374,12 @@ func (i ReplicationControllerConditionPatchArgs) ToReplicationControllerConditio return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerConditionPatchOutput) } +func (i ReplicationControllerConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerConditionPatch] { + return pulumix.Output[ReplicationControllerConditionPatch]{ + OutputState: i.ToReplicationControllerConditionPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerConditionPatchArrayInput is an input type that accepts ReplicationControllerConditionPatchArray and ReplicationControllerConditionPatchArrayOutput values. // You can construct a concrete instance of `ReplicationControllerConditionPatchArrayInput` via: // @@ -50882,6 +57405,12 @@ func (i ReplicationControllerConditionPatchArray) ToReplicationControllerConditi return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerConditionPatchArrayOutput) } +func (i ReplicationControllerConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicationControllerConditionPatch] { + return pulumix.Output[[]ReplicationControllerConditionPatch]{ + OutputState: i.ToReplicationControllerConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerCondition describes the state of a replication controller at a certain point. type ReplicationControllerConditionPatchOutput struct{ *pulumi.OutputState } @@ -50897,6 +57426,12 @@ func (o ReplicationControllerConditionPatchOutput) ToReplicationControllerCondit return o } +func (o ReplicationControllerConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerConditionPatch] { + return pulumix.Output[ReplicationControllerConditionPatch]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicationControllerConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicationControllerConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -50936,6 +57471,12 @@ func (o ReplicationControllerConditionPatchArrayOutput) ToReplicationControllerC return o } +func (o ReplicationControllerConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicationControllerConditionPatch] { + return pulumix.Output[[]ReplicationControllerConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerConditionPatchArrayOutput) Index(i pulumi.IntInput) ReplicationControllerConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicationControllerConditionPatch { return vs[0].([]ReplicationControllerConditionPatch)[vs[1].(int)] @@ -50989,6 +57530,12 @@ func (i ReplicationControllerListTypeArgs) ToReplicationControllerListTypeOutput return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerListTypeOutput) } +func (i ReplicationControllerListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerListType] { + return pulumix.Output[ReplicationControllerListType]{ + OutputState: i.ToReplicationControllerListTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerList is a collection of replication controllers. type ReplicationControllerListTypeOutput struct{ *pulumi.OutputState } @@ -51004,6 +57551,12 @@ func (o ReplicationControllerListTypeOutput) ToReplicationControllerListTypeOutp return o } +func (o ReplicationControllerListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerListType] { + return pulumix.Output[ReplicationControllerListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicationControllerListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicationControllerListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -51075,6 +57628,12 @@ func (i ReplicationControllerPatchTypeArgs) ToReplicationControllerPatchTypeOutp return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerPatchTypeOutput) } +func (i ReplicationControllerPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerPatchType] { + return pulumix.Output[ReplicationControllerPatchType]{ + OutputState: i.ToReplicationControllerPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicationController represents the configuration of a replication controller. type ReplicationControllerPatchTypeOutput struct{ *pulumi.OutputState } @@ -51090,6 +57649,12 @@ func (o ReplicationControllerPatchTypeOutput) ToReplicationControllerPatchTypeOu return o } +func (o ReplicationControllerPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerPatchType] { + return pulumix.Output[ReplicationControllerPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicationControllerPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicationControllerPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -51162,6 +57727,12 @@ func (i ReplicationControllerSpecArgs) ToReplicationControllerSpecOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerSpecOutput) } +func (i ReplicationControllerSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerSpec] { + return pulumix.Output[ReplicationControllerSpec]{ + OutputState: i.ToReplicationControllerSpecOutputWithContext(ctx).OutputState, + } +} + func (i ReplicationControllerSpecArgs) ToReplicationControllerSpecPtrOutput() ReplicationControllerSpecPtrOutput { return i.ToReplicationControllerSpecPtrOutputWithContext(context.Background()) } @@ -51203,6 +57774,12 @@ func (i *replicationControllerSpecPtrType) ToReplicationControllerSpecPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerSpecPtrOutput) } +func (i *replicationControllerSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerSpec] { + return pulumix.Output[*ReplicationControllerSpec]{ + OutputState: i.ToReplicationControllerSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerSpec is the specification of a replication controller. type ReplicationControllerSpecOutput struct{ *pulumi.OutputState } @@ -51228,6 +57805,12 @@ func (o ReplicationControllerSpecOutput) ToReplicationControllerSpecPtrOutputWit }).(ReplicationControllerSpecPtrOutput) } +func (o ReplicationControllerSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerSpec] { + return pulumix.Output[ReplicationControllerSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicationControllerSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicationControllerSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -51262,6 +57845,12 @@ func (o ReplicationControllerSpecPtrOutput) ToReplicationControllerSpecPtrOutput return o } +func (o ReplicationControllerSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerSpec] { + return pulumix.Output[*ReplicationControllerSpec]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerSpecPtrOutput) Elem() ReplicationControllerSpecOutput { return o.ApplyT(func(v *ReplicationControllerSpec) ReplicationControllerSpec { if v != nil { @@ -51359,6 +57948,12 @@ func (i ReplicationControllerSpecPatchArgs) ToReplicationControllerSpecPatchOutp return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerSpecPatchOutput) } +func (i ReplicationControllerSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerSpecPatch] { + return pulumix.Output[ReplicationControllerSpecPatch]{ + OutputState: i.ToReplicationControllerSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicationControllerSpecPatchArgs) ToReplicationControllerSpecPatchPtrOutput() ReplicationControllerSpecPatchPtrOutput { return i.ToReplicationControllerSpecPatchPtrOutputWithContext(context.Background()) } @@ -51400,6 +57995,12 @@ func (i *replicationControllerSpecPatchPtrType) ToReplicationControllerSpecPatch return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerSpecPatchPtrOutput) } +func (i *replicationControllerSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerSpecPatch] { + return pulumix.Output[*ReplicationControllerSpecPatch]{ + OutputState: i.ToReplicationControllerSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerSpec is the specification of a replication controller. type ReplicationControllerSpecPatchOutput struct{ *pulumi.OutputState } @@ -51425,6 +58026,12 @@ func (o ReplicationControllerSpecPatchOutput) ToReplicationControllerSpecPatchPt }).(ReplicationControllerSpecPatchPtrOutput) } +func (o ReplicationControllerSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerSpecPatch] { + return pulumix.Output[ReplicationControllerSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicationControllerSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicationControllerSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -51459,6 +58066,12 @@ func (o ReplicationControllerSpecPatchPtrOutput) ToReplicationControllerSpecPatc return o } +func (o ReplicationControllerSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerSpecPatch] { + return pulumix.Output[*ReplicationControllerSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerSpecPatchPtrOutput) Elem() ReplicationControllerSpecPatchOutput { return o.ApplyT(func(v *ReplicationControllerSpecPatch) ReplicationControllerSpecPatch { if v != nil { @@ -51564,6 +58177,12 @@ func (i ReplicationControllerStatusArgs) ToReplicationControllerStatusOutputWith return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerStatusOutput) } +func (i ReplicationControllerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerStatus] { + return pulumix.Output[ReplicationControllerStatus]{ + OutputState: i.ToReplicationControllerStatusOutputWithContext(ctx).OutputState, + } +} + func (i ReplicationControllerStatusArgs) ToReplicationControllerStatusPtrOutput() ReplicationControllerStatusPtrOutput { return i.ToReplicationControllerStatusPtrOutputWithContext(context.Background()) } @@ -51605,6 +58224,12 @@ func (i *replicationControllerStatusPtrType) ToReplicationControllerStatusPtrOut return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerStatusPtrOutput) } +func (i *replicationControllerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerStatus] { + return pulumix.Output[*ReplicationControllerStatus]{ + OutputState: i.ToReplicationControllerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerStatus represents the current status of a replication controller. type ReplicationControllerStatusOutput struct{ *pulumi.OutputState } @@ -51630,6 +58255,12 @@ func (o ReplicationControllerStatusOutput) ToReplicationControllerStatusPtrOutpu }).(ReplicationControllerStatusPtrOutput) } +func (o ReplicationControllerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerStatus] { + return pulumix.Output[ReplicationControllerStatus]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replication controller. func (o ReplicationControllerStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicationControllerStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -51674,6 +58305,12 @@ func (o ReplicationControllerStatusPtrOutput) ToReplicationControllerStatusPtrOu return o } +func (o ReplicationControllerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerStatus] { + return pulumix.Output[*ReplicationControllerStatus]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerStatusPtrOutput) Elem() ReplicationControllerStatusOutput { return o.ApplyT(func(v *ReplicationControllerStatus) ReplicationControllerStatus { if v != nil { @@ -51799,6 +58436,12 @@ func (i ReplicationControllerStatusPatchArgs) ToReplicationControllerStatusPatch return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerStatusPatchOutput) } +func (i ReplicationControllerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerStatusPatch] { + return pulumix.Output[ReplicationControllerStatusPatch]{ + OutputState: i.ToReplicationControllerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicationControllerStatusPatchArgs) ToReplicationControllerStatusPatchPtrOutput() ReplicationControllerStatusPatchPtrOutput { return i.ToReplicationControllerStatusPatchPtrOutputWithContext(context.Background()) } @@ -51840,6 +58483,12 @@ func (i *replicationControllerStatusPatchPtrType) ToReplicationControllerStatusP return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerStatusPatchPtrOutput) } +func (i *replicationControllerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerStatusPatch] { + return pulumix.Output[*ReplicationControllerStatusPatch]{ + OutputState: i.ToReplicationControllerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerStatus represents the current status of a replication controller. type ReplicationControllerStatusPatchOutput struct{ *pulumi.OutputState } @@ -51865,6 +58514,12 @@ func (o ReplicationControllerStatusPatchOutput) ToReplicationControllerStatusPat }).(ReplicationControllerStatusPatchPtrOutput) } +func (o ReplicationControllerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicationControllerStatusPatch] { + return pulumix.Output[ReplicationControllerStatusPatch]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replication controller. func (o ReplicationControllerStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicationControllerStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -51909,6 +58564,12 @@ func (o ReplicationControllerStatusPatchPtrOutput) ToReplicationControllerStatus return o } +func (o ReplicationControllerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerStatusPatch] { + return pulumix.Output[*ReplicationControllerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerStatusPatchPtrOutput) Elem() ReplicationControllerStatusPatchOutput { return o.ApplyT(func(v *ReplicationControllerStatusPatch) ReplicationControllerStatusPatch { if v != nil { @@ -52014,6 +58675,12 @@ func (i ResourceClaimArgs) ToResourceClaimOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimOutput) } +func (i ResourceClaimArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaim] { + return pulumix.Output[ResourceClaim]{ + OutputState: i.ToResourceClaimOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimArrayInput is an input type that accepts ResourceClaimArray and ResourceClaimArrayOutput values. // You can construct a concrete instance of `ResourceClaimArrayInput` via: // @@ -52039,6 +58706,12 @@ func (i ResourceClaimArray) ToResourceClaimArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimArrayOutput) } +func (i ResourceClaimArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaim] { + return pulumix.Output[[]ResourceClaim]{ + OutputState: i.ToResourceClaimArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaim references one entry in PodSpec.ResourceClaims. type ResourceClaimOutput struct{ *pulumi.OutputState } @@ -52054,6 +58727,12 @@ func (o ResourceClaimOutput) ToResourceClaimOutputWithContext(ctx context.Contex return o } +func (o ResourceClaimOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaim] { + return pulumix.Output[ResourceClaim]{ + OutputState: o.OutputState, + } +} + // Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container. func (o ResourceClaimOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ResourceClaim) string { return v.Name }).(pulumi.StringOutput) @@ -52073,6 +58752,12 @@ func (o ResourceClaimArrayOutput) ToResourceClaimArrayOutputWithContext(ctx cont return o } +func (o ResourceClaimArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaim] { + return pulumix.Output[[]ResourceClaim]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimArrayOutput) Index(i pulumi.IntInput) ResourceClaimOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaim { return vs[0].([]ResourceClaim)[vs[1].(int)] @@ -52114,6 +58799,12 @@ func (i ResourceClaimPatchArgs) ToResourceClaimPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchOutput) } +func (i ResourceClaimPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimPatch] { + return pulumix.Output[ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimPatchArrayInput is an input type that accepts ResourceClaimPatchArray and ResourceClaimPatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimPatchArrayInput` via: // @@ -52139,6 +58830,12 @@ func (i ResourceClaimPatchArray) ToResourceClaimPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchArrayOutput) } +func (i ResourceClaimPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimPatch] { + return pulumix.Output[[]ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaim references one entry in PodSpec.ResourceClaims. type ResourceClaimPatchOutput struct{ *pulumi.OutputState } @@ -52154,6 +58851,12 @@ func (o ResourceClaimPatchOutput) ToResourceClaimPatchOutputWithContext(ctx cont return o } +func (o ResourceClaimPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimPatch] { + return pulumix.Output[ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + // Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container. func (o ResourceClaimPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -52173,6 +58876,12 @@ func (o ResourceClaimPatchArrayOutput) ToResourceClaimPatchArrayOutputWithContex return o } +func (o ResourceClaimPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimPatch] { + return pulumix.Output[[]ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimPatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimPatch { return vs[0].([]ResourceClaimPatch)[vs[1].(int)] @@ -52222,6 +58931,12 @@ func (i ResourceFieldSelectorArgs) ToResourceFieldSelectorOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceFieldSelectorOutput) } +func (i ResourceFieldSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceFieldSelector] { + return pulumix.Output[ResourceFieldSelector]{ + OutputState: i.ToResourceFieldSelectorOutputWithContext(ctx).OutputState, + } +} + func (i ResourceFieldSelectorArgs) ToResourceFieldSelectorPtrOutput() ResourceFieldSelectorPtrOutput { return i.ToResourceFieldSelectorPtrOutputWithContext(context.Background()) } @@ -52263,6 +58978,12 @@ func (i *resourceFieldSelectorPtrType) ToResourceFieldSelectorPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ResourceFieldSelectorPtrOutput) } +func (i *resourceFieldSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceFieldSelector] { + return pulumix.Output[*ResourceFieldSelector]{ + OutputState: i.ToResourceFieldSelectorPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceFieldSelector represents container resources (cpu, memory) and their output format type ResourceFieldSelectorOutput struct{ *pulumi.OutputState } @@ -52288,6 +59009,12 @@ func (o ResourceFieldSelectorOutput) ToResourceFieldSelectorPtrOutputWithContext }).(ResourceFieldSelectorPtrOutput) } +func (o ResourceFieldSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceFieldSelector] { + return pulumix.Output[ResourceFieldSelector]{ + OutputState: o.OutputState, + } +} + // Container name: required for volumes, optional for env vars func (o ResourceFieldSelectorOutput) ContainerName() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceFieldSelector) *string { return v.ContainerName }).(pulumi.StringPtrOutput) @@ -52317,6 +59044,12 @@ func (o ResourceFieldSelectorPtrOutput) ToResourceFieldSelectorPtrOutputWithCont return o } +func (o ResourceFieldSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceFieldSelector] { + return pulumix.Output[*ResourceFieldSelector]{ + OutputState: o.OutputState, + } +} + func (o ResourceFieldSelectorPtrOutput) Elem() ResourceFieldSelectorOutput { return o.ApplyT(func(v *ResourceFieldSelector) ResourceFieldSelector { if v != nil { @@ -52400,6 +59133,12 @@ func (i ResourceFieldSelectorPatchArgs) ToResourceFieldSelectorPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourceFieldSelectorPatchOutput) } +func (i ResourceFieldSelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceFieldSelectorPatch] { + return pulumix.Output[ResourceFieldSelectorPatch]{ + OutputState: i.ToResourceFieldSelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceFieldSelectorPatchArgs) ToResourceFieldSelectorPatchPtrOutput() ResourceFieldSelectorPatchPtrOutput { return i.ToResourceFieldSelectorPatchPtrOutputWithContext(context.Background()) } @@ -52441,6 +59180,12 @@ func (i *resourceFieldSelectorPatchPtrType) ToResourceFieldSelectorPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ResourceFieldSelectorPatchPtrOutput) } +func (i *resourceFieldSelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceFieldSelectorPatch] { + return pulumix.Output[*ResourceFieldSelectorPatch]{ + OutputState: i.ToResourceFieldSelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceFieldSelector represents container resources (cpu, memory) and their output format type ResourceFieldSelectorPatchOutput struct{ *pulumi.OutputState } @@ -52466,6 +59211,12 @@ func (o ResourceFieldSelectorPatchOutput) ToResourceFieldSelectorPatchPtrOutputW }).(ResourceFieldSelectorPatchPtrOutput) } +func (o ResourceFieldSelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceFieldSelectorPatch] { + return pulumix.Output[ResourceFieldSelectorPatch]{ + OutputState: o.OutputState, + } +} + // Container name: required for volumes, optional for env vars func (o ResourceFieldSelectorPatchOutput) ContainerName() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceFieldSelectorPatch) *string { return v.ContainerName }).(pulumi.StringPtrOutput) @@ -52495,6 +59246,12 @@ func (o ResourceFieldSelectorPatchPtrOutput) ToResourceFieldSelectorPatchPtrOutp return o } +func (o ResourceFieldSelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceFieldSelectorPatch] { + return pulumix.Output[*ResourceFieldSelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceFieldSelectorPatchPtrOutput) Elem() ResourceFieldSelectorPatchOutput { return o.ApplyT(func(v *ResourceFieldSelectorPatch) ResourceFieldSelectorPatch { if v != nil { @@ -52586,6 +59343,12 @@ func (i ResourceQuotaTypeArgs) ToResourceQuotaTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaTypeOutput) } +func (i ResourceQuotaTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaType] { + return pulumix.Output[ResourceQuotaType]{ + OutputState: i.ToResourceQuotaTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaTypeArrayInput is an input type that accepts ResourceQuotaTypeArray and ResourceQuotaTypeArrayOutput values. // You can construct a concrete instance of `ResourceQuotaTypeArrayInput` via: // @@ -52611,6 +59374,12 @@ func (i ResourceQuotaTypeArray) ToResourceQuotaTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaTypeArrayOutput) } +func (i ResourceQuotaTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceQuotaType] { + return pulumix.Output[[]ResourceQuotaType]{ + OutputState: i.ToResourceQuotaTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceQuota sets aggregate quota restrictions enforced per namespace type ResourceQuotaTypeOutput struct{ *pulumi.OutputState } @@ -52626,6 +59395,12 @@ func (o ResourceQuotaTypeOutput) ToResourceQuotaTypeOutputWithContext(ctx contex return o } +func (o ResourceQuotaTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaType] { + return pulumix.Output[ResourceQuotaType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceQuotaTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceQuotaType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -52665,6 +59440,12 @@ func (o ResourceQuotaTypeArrayOutput) ToResourceQuotaTypeArrayOutputWithContext( return o } +func (o ResourceQuotaTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceQuotaType] { + return pulumix.Output[[]ResourceQuotaType]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaTypeArrayOutput) Index(i pulumi.IntInput) ResourceQuotaTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceQuotaType { return vs[0].([]ResourceQuotaType)[vs[1].(int)] @@ -52718,6 +59499,12 @@ func (i ResourceQuotaListTypeArgs) ToResourceQuotaListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaListTypeOutput) } +func (i ResourceQuotaListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaListType] { + return pulumix.Output[ResourceQuotaListType]{ + OutputState: i.ToResourceQuotaListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaList is a list of ResourceQuota items. type ResourceQuotaListTypeOutput struct{ *pulumi.OutputState } @@ -52733,6 +59520,12 @@ func (o ResourceQuotaListTypeOutput) ToResourceQuotaListTypeOutputWithContext(ct return o } +func (o ResourceQuotaListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaListType] { + return pulumix.Output[ResourceQuotaListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceQuotaListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceQuotaListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -52804,6 +59597,12 @@ func (i ResourceQuotaPatchTypeArgs) ToResourceQuotaPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaPatchTypeOutput) } +func (i ResourceQuotaPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaPatchType] { + return pulumix.Output[ResourceQuotaPatchType]{ + OutputState: i.ToResourceQuotaPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceQuota sets aggregate quota restrictions enforced per namespace type ResourceQuotaPatchTypeOutput struct{ *pulumi.OutputState } @@ -52819,6 +59618,12 @@ func (o ResourceQuotaPatchTypeOutput) ToResourceQuotaPatchTypeOutputWithContext( return o } +func (o ResourceQuotaPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaPatchType] { + return pulumix.Output[ResourceQuotaPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceQuotaPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceQuotaPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -52887,6 +59692,12 @@ func (i ResourceQuotaSpecArgs) ToResourceQuotaSpecOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaSpecOutput) } +func (i ResourceQuotaSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaSpec] { + return pulumix.Output[ResourceQuotaSpec]{ + OutputState: i.ToResourceQuotaSpecOutputWithContext(ctx).OutputState, + } +} + func (i ResourceQuotaSpecArgs) ToResourceQuotaSpecPtrOutput() ResourceQuotaSpecPtrOutput { return i.ToResourceQuotaSpecPtrOutputWithContext(context.Background()) } @@ -52928,6 +59739,12 @@ func (i *resourceQuotaSpecPtrType) ToResourceQuotaSpecPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaSpecPtrOutput) } +func (i *resourceQuotaSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaSpec] { + return pulumix.Output[*ResourceQuotaSpec]{ + OutputState: i.ToResourceQuotaSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaSpec defines the desired hard limits to enforce for Quota. type ResourceQuotaSpecOutput struct{ *pulumi.OutputState } @@ -52953,6 +59770,12 @@ func (o ResourceQuotaSpecOutput) ToResourceQuotaSpecPtrOutputWithContext(ctx con }).(ResourceQuotaSpecPtrOutput) } +func (o ResourceQuotaSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaSpec] { + return pulumix.Output[ResourceQuotaSpec]{ + OutputState: o.OutputState, + } +} + // hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ func (o ResourceQuotaSpecOutput) Hard() pulumi.StringMapOutput { return o.ApplyT(func(v ResourceQuotaSpec) map[string]string { return v.Hard }).(pulumi.StringMapOutput) @@ -52982,6 +59805,12 @@ func (o ResourceQuotaSpecPtrOutput) ToResourceQuotaSpecPtrOutputWithContext(ctx return o } +func (o ResourceQuotaSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaSpec] { + return pulumix.Output[*ResourceQuotaSpec]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaSpecPtrOutput) Elem() ResourceQuotaSpecOutput { return o.ApplyT(func(v *ResourceQuotaSpec) ResourceQuotaSpec { if v != nil { @@ -53065,6 +59894,12 @@ func (i ResourceQuotaSpecPatchArgs) ToResourceQuotaSpecPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaSpecPatchOutput) } +func (i ResourceQuotaSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaSpecPatch] { + return pulumix.Output[ResourceQuotaSpecPatch]{ + OutputState: i.ToResourceQuotaSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceQuotaSpecPatchArgs) ToResourceQuotaSpecPatchPtrOutput() ResourceQuotaSpecPatchPtrOutput { return i.ToResourceQuotaSpecPatchPtrOutputWithContext(context.Background()) } @@ -53106,6 +59941,12 @@ func (i *resourceQuotaSpecPatchPtrType) ToResourceQuotaSpecPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaSpecPatchPtrOutput) } +func (i *resourceQuotaSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaSpecPatch] { + return pulumix.Output[*ResourceQuotaSpecPatch]{ + OutputState: i.ToResourceQuotaSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaSpec defines the desired hard limits to enforce for Quota. type ResourceQuotaSpecPatchOutput struct{ *pulumi.OutputState } @@ -53131,6 +59972,12 @@ func (o ResourceQuotaSpecPatchOutput) ToResourceQuotaSpecPatchPtrOutputWithConte }).(ResourceQuotaSpecPatchPtrOutput) } +func (o ResourceQuotaSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaSpecPatch] { + return pulumix.Output[ResourceQuotaSpecPatch]{ + OutputState: o.OutputState, + } +} + // hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ func (o ResourceQuotaSpecPatchOutput) Hard() pulumi.StringMapOutput { return o.ApplyT(func(v ResourceQuotaSpecPatch) map[string]string { return v.Hard }).(pulumi.StringMapOutput) @@ -53160,6 +60007,12 @@ func (o ResourceQuotaSpecPatchPtrOutput) ToResourceQuotaSpecPatchPtrOutputWithCo return o } +func (o ResourceQuotaSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaSpecPatch] { + return pulumix.Output[*ResourceQuotaSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaSpecPatchPtrOutput) Elem() ResourceQuotaSpecPatchOutput { return o.ApplyT(func(v *ResourceQuotaSpecPatch) ResourceQuotaSpecPatch { if v != nil { @@ -53239,6 +60092,12 @@ func (i ResourceQuotaStatusArgs) ToResourceQuotaStatusOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaStatusOutput) } +func (i ResourceQuotaStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaStatus] { + return pulumix.Output[ResourceQuotaStatus]{ + OutputState: i.ToResourceQuotaStatusOutputWithContext(ctx).OutputState, + } +} + func (i ResourceQuotaStatusArgs) ToResourceQuotaStatusPtrOutput() ResourceQuotaStatusPtrOutput { return i.ToResourceQuotaStatusPtrOutputWithContext(context.Background()) } @@ -53280,6 +60139,12 @@ func (i *resourceQuotaStatusPtrType) ToResourceQuotaStatusPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaStatusPtrOutput) } +func (i *resourceQuotaStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaStatus] { + return pulumix.Output[*ResourceQuotaStatus]{ + OutputState: i.ToResourceQuotaStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaStatus defines the enforced hard limits and observed use. type ResourceQuotaStatusOutput struct{ *pulumi.OutputState } @@ -53305,6 +60170,12 @@ func (o ResourceQuotaStatusOutput) ToResourceQuotaStatusPtrOutputWithContext(ctx }).(ResourceQuotaStatusPtrOutput) } +func (o ResourceQuotaStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaStatus] { + return pulumix.Output[ResourceQuotaStatus]{ + OutputState: o.OutputState, + } +} + // Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ func (o ResourceQuotaStatusOutput) Hard() pulumi.StringMapOutput { return o.ApplyT(func(v ResourceQuotaStatus) map[string]string { return v.Hard }).(pulumi.StringMapOutput) @@ -53329,6 +60200,12 @@ func (o ResourceQuotaStatusPtrOutput) ToResourceQuotaStatusPtrOutputWithContext( return o } +func (o ResourceQuotaStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaStatus] { + return pulumix.Output[*ResourceQuotaStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaStatusPtrOutput) Elem() ResourceQuotaStatusOutput { return o.ApplyT(func(v *ResourceQuotaStatus) ResourceQuotaStatus { if v != nil { @@ -53398,6 +60275,12 @@ func (i ResourceQuotaStatusPatchArgs) ToResourceQuotaStatusPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaStatusPatchOutput) } +func (i ResourceQuotaStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaStatusPatch] { + return pulumix.Output[ResourceQuotaStatusPatch]{ + OutputState: i.ToResourceQuotaStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceQuotaStatusPatchArgs) ToResourceQuotaStatusPatchPtrOutput() ResourceQuotaStatusPatchPtrOutput { return i.ToResourceQuotaStatusPatchPtrOutputWithContext(context.Background()) } @@ -53439,6 +60322,12 @@ func (i *resourceQuotaStatusPatchPtrType) ToResourceQuotaStatusPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaStatusPatchPtrOutput) } +func (i *resourceQuotaStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaStatusPatch] { + return pulumix.Output[*ResourceQuotaStatusPatch]{ + OutputState: i.ToResourceQuotaStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaStatus defines the enforced hard limits and observed use. type ResourceQuotaStatusPatchOutput struct{ *pulumi.OutputState } @@ -53464,6 +60353,12 @@ func (o ResourceQuotaStatusPatchOutput) ToResourceQuotaStatusPatchPtrOutputWithC }).(ResourceQuotaStatusPatchPtrOutput) } +func (o ResourceQuotaStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceQuotaStatusPatch] { + return pulumix.Output[ResourceQuotaStatusPatch]{ + OutputState: o.OutputState, + } +} + // Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ func (o ResourceQuotaStatusPatchOutput) Hard() pulumi.StringMapOutput { return o.ApplyT(func(v ResourceQuotaStatusPatch) map[string]string { return v.Hard }).(pulumi.StringMapOutput) @@ -53488,6 +60383,12 @@ func (o ResourceQuotaStatusPatchPtrOutput) ToResourceQuotaStatusPatchPtrOutputWi return o } +func (o ResourceQuotaStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaStatusPatch] { + return pulumix.Output[*ResourceQuotaStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaStatusPatchPtrOutput) Elem() ResourceQuotaStatusPatchOutput { return o.ApplyT(func(v *ResourceQuotaStatusPatch) ResourceQuotaStatusPatch { if v != nil { @@ -53569,6 +60470,12 @@ func (i ResourceRequirementsArgs) ToResourceRequirementsOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceRequirementsOutput) } +func (i ResourceRequirementsArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceRequirements] { + return pulumix.Output[ResourceRequirements]{ + OutputState: i.ToResourceRequirementsOutputWithContext(ctx).OutputState, + } +} + func (i ResourceRequirementsArgs) ToResourceRequirementsPtrOutput() ResourceRequirementsPtrOutput { return i.ToResourceRequirementsPtrOutputWithContext(context.Background()) } @@ -53610,6 +60517,12 @@ func (i *resourceRequirementsPtrType) ToResourceRequirementsPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceRequirementsPtrOutput) } +func (i *resourceRequirementsPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceRequirements] { + return pulumix.Output[*ResourceRequirements]{ + OutputState: i.ToResourceRequirementsPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceRequirements describes the compute resource requirements. type ResourceRequirementsOutput struct{ *pulumi.OutputState } @@ -53635,6 +60548,12 @@ func (o ResourceRequirementsOutput) ToResourceRequirementsPtrOutputWithContext(c }).(ResourceRequirementsPtrOutput) } +func (o ResourceRequirementsOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceRequirements] { + return pulumix.Output[ResourceRequirements]{ + OutputState: o.OutputState, + } +} + // Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. // // This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. @@ -53668,6 +60587,12 @@ func (o ResourceRequirementsPtrOutput) ToResourceRequirementsPtrOutputWithContex return o } +func (o ResourceRequirementsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceRequirements] { + return pulumix.Output[*ResourceRequirements]{ + OutputState: o.OutputState, + } +} + func (o ResourceRequirementsPtrOutput) Elem() ResourceRequirementsOutput { return o.ApplyT(func(v *ResourceRequirements) ResourceRequirements { if v != nil { @@ -53763,6 +60688,12 @@ func (i ResourceRequirementsPatchArgs) ToResourceRequirementsPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceRequirementsPatchOutput) } +func (i ResourceRequirementsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceRequirementsPatch] { + return pulumix.Output[ResourceRequirementsPatch]{ + OutputState: i.ToResourceRequirementsPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceRequirementsPatchArgs) ToResourceRequirementsPatchPtrOutput() ResourceRequirementsPatchPtrOutput { return i.ToResourceRequirementsPatchPtrOutputWithContext(context.Background()) } @@ -53804,6 +60735,12 @@ func (i *resourceRequirementsPatchPtrType) ToResourceRequirementsPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ResourceRequirementsPatchPtrOutput) } +func (i *resourceRequirementsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceRequirementsPatch] { + return pulumix.Output[*ResourceRequirementsPatch]{ + OutputState: i.ToResourceRequirementsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceRequirements describes the compute resource requirements. type ResourceRequirementsPatchOutput struct{ *pulumi.OutputState } @@ -53829,6 +60766,12 @@ func (o ResourceRequirementsPatchOutput) ToResourceRequirementsPatchPtrOutputWit }).(ResourceRequirementsPatchPtrOutput) } +func (o ResourceRequirementsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceRequirementsPatch] { + return pulumix.Output[ResourceRequirementsPatch]{ + OutputState: o.OutputState, + } +} + // Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. // // This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. @@ -53862,6 +60805,12 @@ func (o ResourceRequirementsPatchPtrOutput) ToResourceRequirementsPatchPtrOutput return o } +func (o ResourceRequirementsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceRequirementsPatch] { + return pulumix.Output[*ResourceRequirementsPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceRequirementsPatchPtrOutput) Elem() ResourceRequirementsPatchOutput { return o.ApplyT(func(v *ResourceRequirementsPatch) ResourceRequirementsPatch { if v != nil { @@ -53953,6 +60902,12 @@ func (i SELinuxOptionsArgs) ToSELinuxOptionsOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(SELinuxOptionsOutput) } +func (i SELinuxOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[SELinuxOptions] { + return pulumix.Output[SELinuxOptions]{ + OutputState: i.ToSELinuxOptionsOutputWithContext(ctx).OutputState, + } +} + func (i SELinuxOptionsArgs) ToSELinuxOptionsPtrOutput() SELinuxOptionsPtrOutput { return i.ToSELinuxOptionsPtrOutputWithContext(context.Background()) } @@ -53994,6 +60949,12 @@ func (i *selinuxOptionsPtrType) ToSELinuxOptionsPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(SELinuxOptionsPtrOutput) } +func (i *selinuxOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*SELinuxOptions] { + return pulumix.Output[*SELinuxOptions]{ + OutputState: i.ToSELinuxOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // SELinuxOptions are the labels to be applied to the container type SELinuxOptionsOutput struct{ *pulumi.OutputState } @@ -54019,6 +60980,12 @@ func (o SELinuxOptionsOutput) ToSELinuxOptionsPtrOutputWithContext(ctx context.C }).(SELinuxOptionsPtrOutput) } +func (o SELinuxOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[SELinuxOptions] { + return pulumix.Output[SELinuxOptions]{ + OutputState: o.OutputState, + } +} + // Level is SELinux level label that applies to the container. func (o SELinuxOptionsOutput) Level() pulumi.StringPtrOutput { return o.ApplyT(func(v SELinuxOptions) *string { return v.Level }).(pulumi.StringPtrOutput) @@ -54053,6 +61020,12 @@ func (o SELinuxOptionsPtrOutput) ToSELinuxOptionsPtrOutputWithContext(ctx contex return o } +func (o SELinuxOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SELinuxOptions] { + return pulumix.Output[*SELinuxOptions]{ + OutputState: o.OutputState, + } +} + func (o SELinuxOptionsPtrOutput) Elem() SELinuxOptionsOutput { return o.ApplyT(func(v *SELinuxOptions) SELinuxOptions { if v != nil { @@ -54150,6 +61123,12 @@ func (i SELinuxOptionsPatchArgs) ToSELinuxOptionsPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(SELinuxOptionsPatchOutput) } +func (i SELinuxOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SELinuxOptionsPatch] { + return pulumix.Output[SELinuxOptionsPatch]{ + OutputState: i.ToSELinuxOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i SELinuxOptionsPatchArgs) ToSELinuxOptionsPatchPtrOutput() SELinuxOptionsPatchPtrOutput { return i.ToSELinuxOptionsPatchPtrOutputWithContext(context.Background()) } @@ -54191,6 +61170,12 @@ func (i *selinuxOptionsPatchPtrType) ToSELinuxOptionsPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(SELinuxOptionsPatchPtrOutput) } +func (i *selinuxOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SELinuxOptionsPatch] { + return pulumix.Output[*SELinuxOptionsPatch]{ + OutputState: i.ToSELinuxOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SELinuxOptions are the labels to be applied to the container type SELinuxOptionsPatchOutput struct{ *pulumi.OutputState } @@ -54216,6 +61201,12 @@ func (o SELinuxOptionsPatchOutput) ToSELinuxOptionsPatchPtrOutputWithContext(ctx }).(SELinuxOptionsPatchPtrOutput) } +func (o SELinuxOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SELinuxOptionsPatch] { + return pulumix.Output[SELinuxOptionsPatch]{ + OutputState: o.OutputState, + } +} + // Level is SELinux level label that applies to the container. func (o SELinuxOptionsPatchOutput) Level() pulumi.StringPtrOutput { return o.ApplyT(func(v SELinuxOptionsPatch) *string { return v.Level }).(pulumi.StringPtrOutput) @@ -54250,6 +61241,12 @@ func (o SELinuxOptionsPatchPtrOutput) ToSELinuxOptionsPatchPtrOutputWithContext( return o } +func (o SELinuxOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SELinuxOptionsPatch] { + return pulumix.Output[*SELinuxOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o SELinuxOptionsPatchPtrOutput) Elem() SELinuxOptionsPatchOutput { return o.ApplyT(func(v *SELinuxOptionsPatch) SELinuxOptionsPatch { if v != nil { @@ -54371,6 +61368,12 @@ func (i ScaleIOPersistentVolumeSourceArgs) ToScaleIOPersistentVolumeSourceOutput return pulumi.ToOutputWithContext(ctx, i).(ScaleIOPersistentVolumeSourceOutput) } +func (i ScaleIOPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleIOPersistentVolumeSource] { + return pulumix.Output[ScaleIOPersistentVolumeSource]{ + OutputState: i.ToScaleIOPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i ScaleIOPersistentVolumeSourceArgs) ToScaleIOPersistentVolumeSourcePtrOutput() ScaleIOPersistentVolumeSourcePtrOutput { return i.ToScaleIOPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -54412,6 +61415,12 @@ func (i *scaleIOPersistentVolumeSourcePtrType) ToScaleIOPersistentVolumeSourcePt return pulumi.ToOutputWithContext(ctx, i).(ScaleIOPersistentVolumeSourcePtrOutput) } +func (i *scaleIOPersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOPersistentVolumeSource] { + return pulumix.Output[*ScaleIOPersistentVolumeSource]{ + OutputState: i.ToScaleIOPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume type ScaleIOPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -54437,6 +61446,12 @@ func (o ScaleIOPersistentVolumeSourceOutput) ToScaleIOPersistentVolumeSourcePtrO }).(ScaleIOPersistentVolumeSourcePtrOutput) } +func (o ScaleIOPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleIOPersistentVolumeSource] { + return pulumix.Output[ScaleIOPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Default is "xfs" func (o ScaleIOPersistentVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v ScaleIOPersistentVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -54501,6 +61516,12 @@ func (o ScaleIOPersistentVolumeSourcePtrOutput) ToScaleIOPersistentVolumeSourceP return o } +func (o ScaleIOPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOPersistentVolumeSource] { + return pulumix.Output[*ScaleIOPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o ScaleIOPersistentVolumeSourcePtrOutput) Elem() ScaleIOPersistentVolumeSourceOutput { return o.ApplyT(func(v *ScaleIOPersistentVolumeSource) ScaleIOPersistentVolumeSource { if v != nil { @@ -54682,6 +61703,12 @@ func (i ScaleIOPersistentVolumeSourcePatchArgs) ToScaleIOPersistentVolumeSourceP return pulumi.ToOutputWithContext(ctx, i).(ScaleIOPersistentVolumeSourcePatchOutput) } +func (i ScaleIOPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleIOPersistentVolumeSourcePatch] { + return pulumix.Output[ScaleIOPersistentVolumeSourcePatch]{ + OutputState: i.ToScaleIOPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleIOPersistentVolumeSourcePatchArgs) ToScaleIOPersistentVolumeSourcePatchPtrOutput() ScaleIOPersistentVolumeSourcePatchPtrOutput { return i.ToScaleIOPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -54723,6 +61750,12 @@ func (i *scaleIOPersistentVolumeSourcePatchPtrType) ToScaleIOPersistentVolumeSou return pulumi.ToOutputWithContext(ctx, i).(ScaleIOPersistentVolumeSourcePatchPtrOutput) } +func (i *scaleIOPersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOPersistentVolumeSourcePatch] { + return pulumix.Output[*ScaleIOPersistentVolumeSourcePatch]{ + OutputState: i.ToScaleIOPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume type ScaleIOPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -54748,6 +61781,12 @@ func (o ScaleIOPersistentVolumeSourcePatchOutput) ToScaleIOPersistentVolumeSourc }).(ScaleIOPersistentVolumeSourcePatchPtrOutput) } +func (o ScaleIOPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleIOPersistentVolumeSourcePatch] { + return pulumix.Output[ScaleIOPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Default is "xfs" func (o ScaleIOPersistentVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v ScaleIOPersistentVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -54812,6 +61851,12 @@ func (o ScaleIOPersistentVolumeSourcePatchPtrOutput) ToScaleIOPersistentVolumeSo return o } +func (o ScaleIOPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOPersistentVolumeSourcePatch] { + return pulumix.Output[*ScaleIOPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleIOPersistentVolumeSourcePatchPtrOutput) Elem() ScaleIOPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *ScaleIOPersistentVolumeSourcePatch) ScaleIOPersistentVolumeSourcePatch { if v != nil { @@ -54993,6 +62038,12 @@ func (i ScaleIOVolumeSourceArgs) ToScaleIOVolumeSourceOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ScaleIOVolumeSourceOutput) } +func (i ScaleIOVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleIOVolumeSource] { + return pulumix.Output[ScaleIOVolumeSource]{ + OutputState: i.ToScaleIOVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i ScaleIOVolumeSourceArgs) ToScaleIOVolumeSourcePtrOutput() ScaleIOVolumeSourcePtrOutput { return i.ToScaleIOVolumeSourcePtrOutputWithContext(context.Background()) } @@ -55034,6 +62085,12 @@ func (i *scaleIOVolumeSourcePtrType) ToScaleIOVolumeSourcePtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ScaleIOVolumeSourcePtrOutput) } +func (i *scaleIOVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOVolumeSource] { + return pulumix.Output[*ScaleIOVolumeSource]{ + OutputState: i.ToScaleIOVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // ScaleIOVolumeSource represents a persistent ScaleIO volume type ScaleIOVolumeSourceOutput struct{ *pulumi.OutputState } @@ -55059,6 +62116,12 @@ func (o ScaleIOVolumeSourceOutput) ToScaleIOVolumeSourcePtrOutputWithContext(ctx }).(ScaleIOVolumeSourcePtrOutput) } +func (o ScaleIOVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleIOVolumeSource] { + return pulumix.Output[ScaleIOVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Default is "xfs". func (o ScaleIOVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v ScaleIOVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -55123,6 +62186,12 @@ func (o ScaleIOVolumeSourcePtrOutput) ToScaleIOVolumeSourcePtrOutputWithContext( return o } +func (o ScaleIOVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOVolumeSource] { + return pulumix.Output[*ScaleIOVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o ScaleIOVolumeSourcePtrOutput) Elem() ScaleIOVolumeSourceOutput { return o.ApplyT(func(v *ScaleIOVolumeSource) ScaleIOVolumeSource { if v != nil { @@ -55304,6 +62373,12 @@ func (i ScaleIOVolumeSourcePatchArgs) ToScaleIOVolumeSourcePatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ScaleIOVolumeSourcePatchOutput) } +func (i ScaleIOVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleIOVolumeSourcePatch] { + return pulumix.Output[ScaleIOVolumeSourcePatch]{ + OutputState: i.ToScaleIOVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleIOVolumeSourcePatchArgs) ToScaleIOVolumeSourcePatchPtrOutput() ScaleIOVolumeSourcePatchPtrOutput { return i.ToScaleIOVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -55345,6 +62420,12 @@ func (i *scaleIOVolumeSourcePatchPtrType) ToScaleIOVolumeSourcePatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ScaleIOVolumeSourcePatchPtrOutput) } +func (i *scaleIOVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOVolumeSourcePatch] { + return pulumix.Output[*ScaleIOVolumeSourcePatch]{ + OutputState: i.ToScaleIOVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ScaleIOVolumeSource represents a persistent ScaleIO volume type ScaleIOVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -55370,6 +62451,12 @@ func (o ScaleIOVolumeSourcePatchOutput) ToScaleIOVolumeSourcePatchPtrOutputWithC }).(ScaleIOVolumeSourcePatchPtrOutput) } +func (o ScaleIOVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleIOVolumeSourcePatch] { + return pulumix.Output[ScaleIOVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Default is "xfs". func (o ScaleIOVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v ScaleIOVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -55434,6 +62521,12 @@ func (o ScaleIOVolumeSourcePatchPtrOutput) ToScaleIOVolumeSourcePatchPtrOutputWi return o } +func (o ScaleIOVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleIOVolumeSourcePatch] { + return pulumix.Output[*ScaleIOVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleIOVolumeSourcePatchPtrOutput) Elem() ScaleIOVolumeSourcePatchOutput { return o.ApplyT(func(v *ScaleIOVolumeSourcePatch) ScaleIOVolumeSourcePatch { if v != nil { @@ -55579,6 +62672,12 @@ func (i ScopeSelectorArgs) ToScopeSelectorOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ScopeSelectorOutput) } +func (i ScopeSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[ScopeSelector] { + return pulumix.Output[ScopeSelector]{ + OutputState: i.ToScopeSelectorOutputWithContext(ctx).OutputState, + } +} + func (i ScopeSelectorArgs) ToScopeSelectorPtrOutput() ScopeSelectorPtrOutput { return i.ToScopeSelectorPtrOutputWithContext(context.Background()) } @@ -55620,6 +62719,12 @@ func (i *scopeSelectorPtrType) ToScopeSelectorPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ScopeSelectorPtrOutput) } +func (i *scopeSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScopeSelector] { + return pulumix.Output[*ScopeSelector]{ + OutputState: i.ToScopeSelectorPtrOutputWithContext(ctx).OutputState, + } +} + // A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements. type ScopeSelectorOutput struct{ *pulumi.OutputState } @@ -55645,6 +62750,12 @@ func (o ScopeSelectorOutput) ToScopeSelectorPtrOutputWithContext(ctx context.Con }).(ScopeSelectorPtrOutput) } +func (o ScopeSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[ScopeSelector] { + return pulumix.Output[ScopeSelector]{ + OutputState: o.OutputState, + } +} + // A list of scope selector requirements by scope of the resources. func (o ScopeSelectorOutput) MatchExpressions() ScopedResourceSelectorRequirementArrayOutput { return o.ApplyT(func(v ScopeSelector) []ScopedResourceSelectorRequirement { return v.MatchExpressions }).(ScopedResourceSelectorRequirementArrayOutput) @@ -55664,6 +62775,12 @@ func (o ScopeSelectorPtrOutput) ToScopeSelectorPtrOutputWithContext(ctx context. return o } +func (o ScopeSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScopeSelector] { + return pulumix.Output[*ScopeSelector]{ + OutputState: o.OutputState, + } +} + func (o ScopeSelectorPtrOutput) Elem() ScopeSelectorOutput { return o.ApplyT(func(v *ScopeSelector) ScopeSelector { if v != nil { @@ -55719,6 +62836,12 @@ func (i ScopeSelectorPatchArgs) ToScopeSelectorPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ScopeSelectorPatchOutput) } +func (i ScopeSelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScopeSelectorPatch] { + return pulumix.Output[ScopeSelectorPatch]{ + OutputState: i.ToScopeSelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScopeSelectorPatchArgs) ToScopeSelectorPatchPtrOutput() ScopeSelectorPatchPtrOutput { return i.ToScopeSelectorPatchPtrOutputWithContext(context.Background()) } @@ -55760,6 +62883,12 @@ func (i *scopeSelectorPatchPtrType) ToScopeSelectorPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ScopeSelectorPatchPtrOutput) } +func (i *scopeSelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScopeSelectorPatch] { + return pulumix.Output[*ScopeSelectorPatch]{ + OutputState: i.ToScopeSelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements. type ScopeSelectorPatchOutput struct{ *pulumi.OutputState } @@ -55785,6 +62914,12 @@ func (o ScopeSelectorPatchOutput) ToScopeSelectorPatchPtrOutputWithContext(ctx c }).(ScopeSelectorPatchPtrOutput) } +func (o ScopeSelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScopeSelectorPatch] { + return pulumix.Output[ScopeSelectorPatch]{ + OutputState: o.OutputState, + } +} + // A list of scope selector requirements by scope of the resources. func (o ScopeSelectorPatchOutput) MatchExpressions() ScopedResourceSelectorRequirementPatchArrayOutput { return o.ApplyT(func(v ScopeSelectorPatch) []ScopedResourceSelectorRequirementPatch { return v.MatchExpressions }).(ScopedResourceSelectorRequirementPatchArrayOutput) @@ -55804,6 +62939,12 @@ func (o ScopeSelectorPatchPtrOutput) ToScopeSelectorPatchPtrOutputWithContext(ct return o } +func (o ScopeSelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScopeSelectorPatch] { + return pulumix.Output[*ScopeSelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o ScopeSelectorPatchPtrOutput) Elem() ScopeSelectorPatchOutput { return o.ApplyT(func(v *ScopeSelectorPatch) ScopeSelectorPatch { if v != nil { @@ -55867,6 +63008,12 @@ func (i ScopedResourceSelectorRequirementArgs) ToScopedResourceSelectorRequireme return pulumi.ToOutputWithContext(ctx, i).(ScopedResourceSelectorRequirementOutput) } +func (i ScopedResourceSelectorRequirementArgs) ToOutput(ctx context.Context) pulumix.Output[ScopedResourceSelectorRequirement] { + return pulumix.Output[ScopedResourceSelectorRequirement]{ + OutputState: i.ToScopedResourceSelectorRequirementOutputWithContext(ctx).OutputState, + } +} + // ScopedResourceSelectorRequirementArrayInput is an input type that accepts ScopedResourceSelectorRequirementArray and ScopedResourceSelectorRequirementArrayOutput values. // You can construct a concrete instance of `ScopedResourceSelectorRequirementArrayInput` via: // @@ -55892,6 +63039,12 @@ func (i ScopedResourceSelectorRequirementArray) ToScopedResourceSelectorRequirem return pulumi.ToOutputWithContext(ctx, i).(ScopedResourceSelectorRequirementArrayOutput) } +func (i ScopedResourceSelectorRequirementArray) ToOutput(ctx context.Context) pulumix.Output[[]ScopedResourceSelectorRequirement] { + return pulumix.Output[[]ScopedResourceSelectorRequirement]{ + OutputState: i.ToScopedResourceSelectorRequirementArrayOutputWithContext(ctx).OutputState, + } +} + // A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values. type ScopedResourceSelectorRequirementOutput struct{ *pulumi.OutputState } @@ -55907,6 +63060,12 @@ func (o ScopedResourceSelectorRequirementOutput) ToScopedResourceSelectorRequire return o } +func (o ScopedResourceSelectorRequirementOutput) ToOutput(ctx context.Context) pulumix.Output[ScopedResourceSelectorRequirement] { + return pulumix.Output[ScopedResourceSelectorRequirement]{ + OutputState: o.OutputState, + } +} + // Represents a scope's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. func (o ScopedResourceSelectorRequirementOutput) Operator() pulumi.StringOutput { return o.ApplyT(func(v ScopedResourceSelectorRequirement) string { return v.Operator }).(pulumi.StringOutput) @@ -55936,6 +63095,12 @@ func (o ScopedResourceSelectorRequirementArrayOutput) ToScopedResourceSelectorRe return o } +func (o ScopedResourceSelectorRequirementArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ScopedResourceSelectorRequirement] { + return pulumix.Output[[]ScopedResourceSelectorRequirement]{ + OutputState: o.OutputState, + } +} + func (o ScopedResourceSelectorRequirementArrayOutput) Index(i pulumi.IntInput) ScopedResourceSelectorRequirementOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ScopedResourceSelectorRequirement { return vs[0].([]ScopedResourceSelectorRequirement)[vs[1].(int)] @@ -55985,6 +63150,12 @@ func (i ScopedResourceSelectorRequirementPatchArgs) ToScopedResourceSelectorRequ return pulumi.ToOutputWithContext(ctx, i).(ScopedResourceSelectorRequirementPatchOutput) } +func (i ScopedResourceSelectorRequirementPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScopedResourceSelectorRequirementPatch] { + return pulumix.Output[ScopedResourceSelectorRequirementPatch]{ + OutputState: i.ToScopedResourceSelectorRequirementPatchOutputWithContext(ctx).OutputState, + } +} + // ScopedResourceSelectorRequirementPatchArrayInput is an input type that accepts ScopedResourceSelectorRequirementPatchArray and ScopedResourceSelectorRequirementPatchArrayOutput values. // You can construct a concrete instance of `ScopedResourceSelectorRequirementPatchArrayInput` via: // @@ -56010,6 +63181,12 @@ func (i ScopedResourceSelectorRequirementPatchArray) ToScopedResourceSelectorReq return pulumi.ToOutputWithContext(ctx, i).(ScopedResourceSelectorRequirementPatchArrayOutput) } +func (i ScopedResourceSelectorRequirementPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ScopedResourceSelectorRequirementPatch] { + return pulumix.Output[[]ScopedResourceSelectorRequirementPatch]{ + OutputState: i.ToScopedResourceSelectorRequirementPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values. type ScopedResourceSelectorRequirementPatchOutput struct{ *pulumi.OutputState } @@ -56025,6 +63202,12 @@ func (o ScopedResourceSelectorRequirementPatchOutput) ToScopedResourceSelectorRe return o } +func (o ScopedResourceSelectorRequirementPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScopedResourceSelectorRequirementPatch] { + return pulumix.Output[ScopedResourceSelectorRequirementPatch]{ + OutputState: o.OutputState, + } +} + // Represents a scope's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. func (o ScopedResourceSelectorRequirementPatchOutput) Operator() pulumi.StringPtrOutput { return o.ApplyT(func(v ScopedResourceSelectorRequirementPatch) *string { return v.Operator }).(pulumi.StringPtrOutput) @@ -56054,6 +63237,12 @@ func (o ScopedResourceSelectorRequirementPatchArrayOutput) ToScopedResourceSelec return o } +func (o ScopedResourceSelectorRequirementPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ScopedResourceSelectorRequirementPatch] { + return pulumix.Output[[]ScopedResourceSelectorRequirementPatch]{ + OutputState: o.OutputState, + } +} + func (o ScopedResourceSelectorRequirementPatchArrayOutput) Index(i pulumi.IntInput) ScopedResourceSelectorRequirementPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ScopedResourceSelectorRequirementPatch { return vs[0].([]ScopedResourceSelectorRequirementPatch)[vs[1].(int)] @@ -56103,6 +63292,12 @@ func (i SeccompProfileArgs) ToSeccompProfileOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(SeccompProfileOutput) } +func (i SeccompProfileArgs) ToOutput(ctx context.Context) pulumix.Output[SeccompProfile] { + return pulumix.Output[SeccompProfile]{ + OutputState: i.ToSeccompProfileOutputWithContext(ctx).OutputState, + } +} + func (i SeccompProfileArgs) ToSeccompProfilePtrOutput() SeccompProfilePtrOutput { return i.ToSeccompProfilePtrOutputWithContext(context.Background()) } @@ -56144,6 +63339,12 @@ func (i *seccompProfilePtrType) ToSeccompProfilePtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(SeccompProfilePtrOutput) } +func (i *seccompProfilePtrType) ToOutput(ctx context.Context) pulumix.Output[*SeccompProfile] { + return pulumix.Output[*SeccompProfile]{ + OutputState: i.ToSeccompProfilePtrOutputWithContext(ctx).OutputState, + } +} + // SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set. type SeccompProfileOutput struct{ *pulumi.OutputState } @@ -56169,6 +63370,12 @@ func (o SeccompProfileOutput) ToSeccompProfilePtrOutputWithContext(ctx context.C }).(SeccompProfilePtrOutput) } +func (o SeccompProfileOutput) ToOutput(ctx context.Context) pulumix.Output[SeccompProfile] { + return pulumix.Output[SeccompProfile]{ + OutputState: o.OutputState, + } +} + // localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is "Localhost". Must NOT be set for any other type. func (o SeccompProfileOutput) LocalhostProfile() pulumi.StringPtrOutput { return o.ApplyT(func(v SeccompProfile) *string { return v.LocalhostProfile }).(pulumi.StringPtrOutput) @@ -56195,6 +63402,12 @@ func (o SeccompProfilePtrOutput) ToSeccompProfilePtrOutputWithContext(ctx contex return o } +func (o SeccompProfilePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SeccompProfile] { + return pulumix.Output[*SeccompProfile]{ + OutputState: o.OutputState, + } +} + func (o SeccompProfilePtrOutput) Elem() SeccompProfileOutput { return o.ApplyT(func(v *SeccompProfile) SeccompProfile { if v != nil { @@ -56270,6 +63483,12 @@ func (i SeccompProfilePatchArgs) ToSeccompProfilePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(SeccompProfilePatchOutput) } +func (i SeccompProfilePatchArgs) ToOutput(ctx context.Context) pulumix.Output[SeccompProfilePatch] { + return pulumix.Output[SeccompProfilePatch]{ + OutputState: i.ToSeccompProfilePatchOutputWithContext(ctx).OutputState, + } +} + func (i SeccompProfilePatchArgs) ToSeccompProfilePatchPtrOutput() SeccompProfilePatchPtrOutput { return i.ToSeccompProfilePatchPtrOutputWithContext(context.Background()) } @@ -56311,6 +63530,12 @@ func (i *seccompProfilePatchPtrType) ToSeccompProfilePatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(SeccompProfilePatchPtrOutput) } +func (i *seccompProfilePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SeccompProfilePatch] { + return pulumix.Output[*SeccompProfilePatch]{ + OutputState: i.ToSeccompProfilePatchPtrOutputWithContext(ctx).OutputState, + } +} + // SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set. type SeccompProfilePatchOutput struct{ *pulumi.OutputState } @@ -56336,6 +63561,12 @@ func (o SeccompProfilePatchOutput) ToSeccompProfilePatchPtrOutputWithContext(ctx }).(SeccompProfilePatchPtrOutput) } +func (o SeccompProfilePatchOutput) ToOutput(ctx context.Context) pulumix.Output[SeccompProfilePatch] { + return pulumix.Output[SeccompProfilePatch]{ + OutputState: o.OutputState, + } +} + // localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is "Localhost". Must NOT be set for any other type. func (o SeccompProfilePatchOutput) LocalhostProfile() pulumi.StringPtrOutput { return o.ApplyT(func(v SeccompProfilePatch) *string { return v.LocalhostProfile }).(pulumi.StringPtrOutput) @@ -56362,6 +63593,12 @@ func (o SeccompProfilePatchPtrOutput) ToSeccompProfilePatchPtrOutputWithContext( return o } +func (o SeccompProfilePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SeccompProfilePatch] { + return pulumix.Output[*SeccompProfilePatch]{ + OutputState: o.OutputState, + } +} + func (o SeccompProfilePatchPtrOutput) Elem() SeccompProfilePatchOutput { return o.ApplyT(func(v *SeccompProfilePatch) SeccompProfilePatch { if v != nil { @@ -56473,6 +63710,12 @@ func (i SecretTypeArgs) ToSecretTypeOutputWithContext(ctx context.Context) Secre return pulumi.ToOutputWithContext(ctx, i).(SecretTypeOutput) } +func (i SecretTypeArgs) ToOutput(ctx context.Context) pulumix.Output[SecretType] { + return pulumix.Output[SecretType]{ + OutputState: i.ToSecretTypeOutputWithContext(ctx).OutputState, + } +} + // SecretTypeArrayInput is an input type that accepts SecretTypeArray and SecretTypeArrayOutput values. // You can construct a concrete instance of `SecretTypeArrayInput` via: // @@ -56498,6 +63741,12 @@ func (i SecretTypeArray) ToSecretTypeArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(SecretTypeArrayOutput) } +func (i SecretTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]SecretType] { + return pulumix.Output[[]SecretType]{ + OutputState: i.ToSecretTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes. // // Note: While Pulumi automatically encrypts the 'data' and 'stringData' @@ -56523,6 +63772,12 @@ func (o SecretTypeOutput) ToSecretTypeOutputWithContext(ctx context.Context) Sec return o } +func (o SecretTypeOutput) ToOutput(ctx context.Context) pulumix.Output[SecretType] { + return pulumix.Output[SecretType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SecretTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -56572,6 +63827,12 @@ func (o SecretTypeArrayOutput) ToSecretTypeArrayOutputWithContext(ctx context.Co return o } +func (o SecretTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SecretType] { + return pulumix.Output[[]SecretType]{ + OutputState: o.OutputState, + } +} + func (o SecretTypeArrayOutput) Index(i pulumi.IntInput) SecretTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretType { return vs[0].([]SecretType)[vs[1].(int)] @@ -56621,6 +63882,12 @@ func (i SecretEnvSourceArgs) ToSecretEnvSourceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SecretEnvSourceOutput) } +func (i SecretEnvSourceArgs) ToOutput(ctx context.Context) pulumix.Output[SecretEnvSource] { + return pulumix.Output[SecretEnvSource]{ + OutputState: i.ToSecretEnvSourceOutputWithContext(ctx).OutputState, + } +} + func (i SecretEnvSourceArgs) ToSecretEnvSourcePtrOutput() SecretEnvSourcePtrOutput { return i.ToSecretEnvSourcePtrOutputWithContext(context.Background()) } @@ -56662,6 +63929,12 @@ func (i *secretEnvSourcePtrType) ToSecretEnvSourcePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(SecretEnvSourcePtrOutput) } +func (i *secretEnvSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretEnvSource] { + return pulumix.Output[*SecretEnvSource]{ + OutputState: i.ToSecretEnvSourcePtrOutputWithContext(ctx).OutputState, + } +} + // SecretEnvSource selects a Secret to populate the environment variables with. // // The contents of the target Secret's Data field will represent the key-value pairs as environment variables. @@ -56689,6 +63962,12 @@ func (o SecretEnvSourceOutput) ToSecretEnvSourcePtrOutputWithContext(ctx context }).(SecretEnvSourcePtrOutput) } +func (o SecretEnvSourceOutput) ToOutput(ctx context.Context) pulumix.Output[SecretEnvSource] { + return pulumix.Output[SecretEnvSource]{ + OutputState: o.OutputState, + } +} + // Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names func (o SecretEnvSourceOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretEnvSource) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -56713,6 +63992,12 @@ func (o SecretEnvSourcePtrOutput) ToSecretEnvSourcePtrOutputWithContext(ctx cont return o } +func (o SecretEnvSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretEnvSource] { + return pulumix.Output[*SecretEnvSource]{ + OutputState: o.OutputState, + } +} + func (o SecretEnvSourcePtrOutput) Elem() SecretEnvSourceOutput { return o.ApplyT(func(v *SecretEnvSource) SecretEnvSource { if v != nil { @@ -56786,6 +64071,12 @@ func (i SecretEnvSourcePatchArgs) ToSecretEnvSourcePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(SecretEnvSourcePatchOutput) } +func (i SecretEnvSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[SecretEnvSourcePatch] { + return pulumix.Output[SecretEnvSourcePatch]{ + OutputState: i.ToSecretEnvSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i SecretEnvSourcePatchArgs) ToSecretEnvSourcePatchPtrOutput() SecretEnvSourcePatchPtrOutput { return i.ToSecretEnvSourcePatchPtrOutputWithContext(context.Background()) } @@ -56827,6 +64118,12 @@ func (i *secretEnvSourcePatchPtrType) ToSecretEnvSourcePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(SecretEnvSourcePatchPtrOutput) } +func (i *secretEnvSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretEnvSourcePatch] { + return pulumix.Output[*SecretEnvSourcePatch]{ + OutputState: i.ToSecretEnvSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // SecretEnvSource selects a Secret to populate the environment variables with. // // The contents of the target Secret's Data field will represent the key-value pairs as environment variables. @@ -56854,6 +64151,12 @@ func (o SecretEnvSourcePatchOutput) ToSecretEnvSourcePatchPtrOutputWithContext(c }).(SecretEnvSourcePatchPtrOutput) } +func (o SecretEnvSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[SecretEnvSourcePatch] { + return pulumix.Output[SecretEnvSourcePatch]{ + OutputState: o.OutputState, + } +} + // Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names func (o SecretEnvSourcePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretEnvSourcePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -56878,6 +64181,12 @@ func (o SecretEnvSourcePatchPtrOutput) ToSecretEnvSourcePatchPtrOutputWithContex return o } +func (o SecretEnvSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretEnvSourcePatch] { + return pulumix.Output[*SecretEnvSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o SecretEnvSourcePatchPtrOutput) Elem() SecretEnvSourcePatchOutput { return o.ApplyT(func(v *SecretEnvSourcePatch) SecretEnvSourcePatch { if v != nil { @@ -56951,6 +64260,12 @@ func (i SecretKeySelectorArgs) ToSecretKeySelectorOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(SecretKeySelectorOutput) } +func (i SecretKeySelectorArgs) ToOutput(ctx context.Context) pulumix.Output[SecretKeySelector] { + return pulumix.Output[SecretKeySelector]{ + OutputState: i.ToSecretKeySelectorOutputWithContext(ctx).OutputState, + } +} + func (i SecretKeySelectorArgs) ToSecretKeySelectorPtrOutput() SecretKeySelectorPtrOutput { return i.ToSecretKeySelectorPtrOutputWithContext(context.Background()) } @@ -56992,6 +64307,12 @@ func (i *secretKeySelectorPtrType) ToSecretKeySelectorPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(SecretKeySelectorPtrOutput) } +func (i *secretKeySelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretKeySelector] { + return pulumix.Output[*SecretKeySelector]{ + OutputState: i.ToSecretKeySelectorPtrOutputWithContext(ctx).OutputState, + } +} + // SecretKeySelector selects a key of a Secret. type SecretKeySelectorOutput struct{ *pulumi.OutputState } @@ -57017,6 +64338,12 @@ func (o SecretKeySelectorOutput) ToSecretKeySelectorPtrOutputWithContext(ctx con }).(SecretKeySelectorPtrOutput) } +func (o SecretKeySelectorOutput) ToOutput(ctx context.Context) pulumix.Output[SecretKeySelector] { + return pulumix.Output[SecretKeySelector]{ + OutputState: o.OutputState, + } +} + // The key of the secret to select from. Must be a valid secret key. func (o SecretKeySelectorOutput) Key() pulumi.StringOutput { return o.ApplyT(func(v SecretKeySelector) string { return v.Key }).(pulumi.StringOutput) @@ -57046,6 +64373,12 @@ func (o SecretKeySelectorPtrOutput) ToSecretKeySelectorPtrOutputWithContext(ctx return o } +func (o SecretKeySelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretKeySelector] { + return pulumix.Output[*SecretKeySelector]{ + OutputState: o.OutputState, + } +} + func (o SecretKeySelectorPtrOutput) Elem() SecretKeySelectorOutput { return o.ApplyT(func(v *SecretKeySelector) SecretKeySelector { if v != nil { @@ -57129,6 +64462,12 @@ func (i SecretKeySelectorPatchArgs) ToSecretKeySelectorPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SecretKeySelectorPatchOutput) } +func (i SecretKeySelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SecretKeySelectorPatch] { + return pulumix.Output[SecretKeySelectorPatch]{ + OutputState: i.ToSecretKeySelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i SecretKeySelectorPatchArgs) ToSecretKeySelectorPatchPtrOutput() SecretKeySelectorPatchPtrOutput { return i.ToSecretKeySelectorPatchPtrOutputWithContext(context.Background()) } @@ -57170,6 +64509,12 @@ func (i *secretKeySelectorPatchPtrType) ToSecretKeySelectorPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(SecretKeySelectorPatchPtrOutput) } +func (i *secretKeySelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretKeySelectorPatch] { + return pulumix.Output[*SecretKeySelectorPatch]{ + OutputState: i.ToSecretKeySelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SecretKeySelector selects a key of a Secret. type SecretKeySelectorPatchOutput struct{ *pulumi.OutputState } @@ -57195,6 +64540,12 @@ func (o SecretKeySelectorPatchOutput) ToSecretKeySelectorPatchPtrOutputWithConte }).(SecretKeySelectorPatchPtrOutput) } +func (o SecretKeySelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SecretKeySelectorPatch] { + return pulumix.Output[SecretKeySelectorPatch]{ + OutputState: o.OutputState, + } +} + // The key of the secret to select from. Must be a valid secret key. func (o SecretKeySelectorPatchOutput) Key() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretKeySelectorPatch) *string { return v.Key }).(pulumi.StringPtrOutput) @@ -57224,6 +64575,12 @@ func (o SecretKeySelectorPatchPtrOutput) ToSecretKeySelectorPatchPtrOutputWithCo return o } +func (o SecretKeySelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretKeySelectorPatch] { + return pulumix.Output[*SecretKeySelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o SecretKeySelectorPatchPtrOutput) Elem() SecretKeySelectorPatchOutput { return o.ApplyT(func(v *SecretKeySelectorPatch) SecretKeySelectorPatch { if v != nil { @@ -57311,6 +64668,12 @@ func (i SecretListTypeArgs) ToSecretListTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(SecretListTypeOutput) } +func (i SecretListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[SecretListType] { + return pulumix.Output[SecretListType]{ + OutputState: i.ToSecretListTypeOutputWithContext(ctx).OutputState, + } +} + // SecretList is a list of Secret. type SecretListTypeOutput struct{ *pulumi.OutputState } @@ -57326,6 +64689,12 @@ func (o SecretListTypeOutput) ToSecretListTypeOutputWithContext(ctx context.Cont return o } +func (o SecretListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[SecretListType] { + return pulumix.Output[SecretListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SecretListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -57425,6 +64794,12 @@ func (i SecretPatchTypeArgs) ToSecretPatchTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SecretPatchTypeOutput) } +func (i SecretPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[SecretPatchType] { + return pulumix.Output[SecretPatchType]{ + OutputState: i.ToSecretPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes. // // Note: While Pulumi automatically encrypts the 'data' and 'stringData' @@ -57450,6 +64825,12 @@ func (o SecretPatchTypeOutput) ToSecretPatchTypeOutputWithContext(ctx context.Co return o } +func (o SecretPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[SecretPatchType] { + return pulumix.Output[SecretPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SecretPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -57532,6 +64913,12 @@ func (i SecretProjectionArgs) ToSecretProjectionOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(SecretProjectionOutput) } +func (i SecretProjectionArgs) ToOutput(ctx context.Context) pulumix.Output[SecretProjection] { + return pulumix.Output[SecretProjection]{ + OutputState: i.ToSecretProjectionOutputWithContext(ctx).OutputState, + } +} + func (i SecretProjectionArgs) ToSecretProjectionPtrOutput() SecretProjectionPtrOutput { return i.ToSecretProjectionPtrOutputWithContext(context.Background()) } @@ -57573,6 +64960,12 @@ func (i *secretProjectionPtrType) ToSecretProjectionPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(SecretProjectionPtrOutput) } +func (i *secretProjectionPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretProjection] { + return pulumix.Output[*SecretProjection]{ + OutputState: i.ToSecretProjectionPtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a secret into a projected volume. // // The contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode. @@ -57600,6 +64993,12 @@ func (o SecretProjectionOutput) ToSecretProjectionPtrOutputWithContext(ctx conte }).(SecretProjectionPtrOutput) } +func (o SecretProjectionOutput) ToOutput(ctx context.Context) pulumix.Output[SecretProjection] { + return pulumix.Output[SecretProjection]{ + OutputState: o.OutputState, + } +} + // items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. func (o SecretProjectionOutput) Items() KeyToPathArrayOutput { return o.ApplyT(func(v SecretProjection) []KeyToPath { return v.Items }).(KeyToPathArrayOutput) @@ -57629,6 +65028,12 @@ func (o SecretProjectionPtrOutput) ToSecretProjectionPtrOutputWithContext(ctx co return o } +func (o SecretProjectionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretProjection] { + return pulumix.Output[*SecretProjection]{ + OutputState: o.OutputState, + } +} + func (o SecretProjectionPtrOutput) Elem() SecretProjectionOutput { return o.ApplyT(func(v *SecretProjection) SecretProjection { if v != nil { @@ -57716,6 +65121,12 @@ func (i SecretProjectionPatchArgs) ToSecretProjectionPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(SecretProjectionPatchOutput) } +func (i SecretProjectionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SecretProjectionPatch] { + return pulumix.Output[SecretProjectionPatch]{ + OutputState: i.ToSecretProjectionPatchOutputWithContext(ctx).OutputState, + } +} + func (i SecretProjectionPatchArgs) ToSecretProjectionPatchPtrOutput() SecretProjectionPatchPtrOutput { return i.ToSecretProjectionPatchPtrOutputWithContext(context.Background()) } @@ -57757,6 +65168,12 @@ func (i *secretProjectionPatchPtrType) ToSecretProjectionPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(SecretProjectionPatchPtrOutput) } +func (i *secretProjectionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretProjectionPatch] { + return pulumix.Output[*SecretProjectionPatch]{ + OutputState: i.ToSecretProjectionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a secret into a projected volume. // // The contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode. @@ -57784,6 +65201,12 @@ func (o SecretProjectionPatchOutput) ToSecretProjectionPatchPtrOutputWithContext }).(SecretProjectionPatchPtrOutput) } +func (o SecretProjectionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SecretProjectionPatch] { + return pulumix.Output[SecretProjectionPatch]{ + OutputState: o.OutputState, + } +} + // items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. func (o SecretProjectionPatchOutput) Items() KeyToPathPatchArrayOutput { return o.ApplyT(func(v SecretProjectionPatch) []KeyToPathPatch { return v.Items }).(KeyToPathPatchArrayOutput) @@ -57813,6 +65236,12 @@ func (o SecretProjectionPatchPtrOutput) ToSecretProjectionPatchPtrOutputWithCont return o } +func (o SecretProjectionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretProjectionPatch] { + return pulumix.Output[*SecretProjectionPatch]{ + OutputState: o.OutputState, + } +} + func (o SecretProjectionPatchPtrOutput) Elem() SecretProjectionPatchOutput { return o.ApplyT(func(v *SecretProjectionPatch) SecretProjectionPatch { if v != nil { @@ -57892,6 +65321,12 @@ func (i SecretReferenceArgs) ToSecretReferenceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SecretReferenceOutput) } +func (i SecretReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[SecretReference] { + return pulumix.Output[SecretReference]{ + OutputState: i.ToSecretReferenceOutputWithContext(ctx).OutputState, + } +} + func (i SecretReferenceArgs) ToSecretReferencePtrOutput() SecretReferencePtrOutput { return i.ToSecretReferencePtrOutputWithContext(context.Background()) } @@ -57933,6 +65368,12 @@ func (i *secretReferencePtrType) ToSecretReferencePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(SecretReferencePtrOutput) } +func (i *secretReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretReference] { + return pulumix.Output[*SecretReference]{ + OutputState: i.ToSecretReferencePtrOutputWithContext(ctx).OutputState, + } +} + // SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace type SecretReferenceOutput struct{ *pulumi.OutputState } @@ -57958,6 +65399,12 @@ func (o SecretReferenceOutput) ToSecretReferencePtrOutputWithContext(ctx context }).(SecretReferencePtrOutput) } +func (o SecretReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[SecretReference] { + return pulumix.Output[SecretReference]{ + OutputState: o.OutputState, + } +} + // name is unique within a namespace to reference a secret resource. func (o SecretReferenceOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretReference) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -57982,6 +65429,12 @@ func (o SecretReferencePtrOutput) ToSecretReferencePtrOutputWithContext(ctx cont return o } +func (o SecretReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretReference] { + return pulumix.Output[*SecretReference]{ + OutputState: o.OutputState, + } +} + func (o SecretReferencePtrOutput) Elem() SecretReferenceOutput { return o.ApplyT(func(v *SecretReference) SecretReference { if v != nil { @@ -58051,6 +65504,12 @@ func (i SecretReferencePatchArgs) ToSecretReferencePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(SecretReferencePatchOutput) } +func (i SecretReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[SecretReferencePatch] { + return pulumix.Output[SecretReferencePatch]{ + OutputState: i.ToSecretReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i SecretReferencePatchArgs) ToSecretReferencePatchPtrOutput() SecretReferencePatchPtrOutput { return i.ToSecretReferencePatchPtrOutputWithContext(context.Background()) } @@ -58092,6 +65551,12 @@ func (i *secretReferencePatchPtrType) ToSecretReferencePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(SecretReferencePatchPtrOutput) } +func (i *secretReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretReferencePatch] { + return pulumix.Output[*SecretReferencePatch]{ + OutputState: i.ToSecretReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace type SecretReferencePatchOutput struct{ *pulumi.OutputState } @@ -58117,6 +65582,12 @@ func (o SecretReferencePatchOutput) ToSecretReferencePatchPtrOutputWithContext(c }).(SecretReferencePatchPtrOutput) } +func (o SecretReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[SecretReferencePatch] { + return pulumix.Output[SecretReferencePatch]{ + OutputState: o.OutputState, + } +} + // name is unique within a namespace to reference a secret resource. func (o SecretReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v SecretReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -58141,6 +65612,12 @@ func (o SecretReferencePatchPtrOutput) ToSecretReferencePatchPtrOutputWithContex return o } +func (o SecretReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretReferencePatch] { + return pulumix.Output[*SecretReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o SecretReferencePatchPtrOutput) Elem() SecretReferencePatchOutput { return o.ApplyT(func(v *SecretReferencePatch) SecretReferencePatch { if v != nil { @@ -58222,6 +65699,12 @@ func (i SecretVolumeSourceArgs) ToSecretVolumeSourceOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(SecretVolumeSourceOutput) } +func (i SecretVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[SecretVolumeSource] { + return pulumix.Output[SecretVolumeSource]{ + OutputState: i.ToSecretVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i SecretVolumeSourceArgs) ToSecretVolumeSourcePtrOutput() SecretVolumeSourcePtrOutput { return i.ToSecretVolumeSourcePtrOutputWithContext(context.Background()) } @@ -58263,6 +65746,12 @@ func (i *secretVolumeSourcePtrType) ToSecretVolumeSourcePtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(SecretVolumeSourcePtrOutput) } +func (i *secretVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretVolumeSource] { + return pulumix.Output[*SecretVolumeSource]{ + OutputState: i.ToSecretVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a Secret into a volume. // // The contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling. @@ -58290,6 +65779,12 @@ func (o SecretVolumeSourceOutput) ToSecretVolumeSourcePtrOutputWithContext(ctx c }).(SecretVolumeSourcePtrOutput) } +func (o SecretVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[SecretVolumeSource] { + return pulumix.Output[SecretVolumeSource]{ + OutputState: o.OutputState, + } +} + // defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o SecretVolumeSourceOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v SecretVolumeSource) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -58324,6 +65819,12 @@ func (o SecretVolumeSourcePtrOutput) ToSecretVolumeSourcePtrOutputWithContext(ct return o } +func (o SecretVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretVolumeSource] { + return pulumix.Output[*SecretVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o SecretVolumeSourcePtrOutput) Elem() SecretVolumeSourceOutput { return o.ApplyT(func(v *SecretVolumeSource) SecretVolumeSource { if v != nil { @@ -58425,6 +65926,12 @@ func (i SecretVolumeSourcePatchArgs) ToSecretVolumeSourcePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(SecretVolumeSourcePatchOutput) } +func (i SecretVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[SecretVolumeSourcePatch] { + return pulumix.Output[SecretVolumeSourcePatch]{ + OutputState: i.ToSecretVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i SecretVolumeSourcePatchArgs) ToSecretVolumeSourcePatchPtrOutput() SecretVolumeSourcePatchPtrOutput { return i.ToSecretVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -58466,6 +65973,12 @@ func (i *secretVolumeSourcePatchPtrType) ToSecretVolumeSourcePatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(SecretVolumeSourcePatchPtrOutput) } +func (i *secretVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecretVolumeSourcePatch] { + return pulumix.Output[*SecretVolumeSourcePatch]{ + OutputState: i.ToSecretVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Adapts a Secret into a volume. // // The contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling. @@ -58493,6 +66006,12 @@ func (o SecretVolumeSourcePatchOutput) ToSecretVolumeSourcePatchPtrOutputWithCon }).(SecretVolumeSourcePatchPtrOutput) } +func (o SecretVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[SecretVolumeSourcePatch] { + return pulumix.Output[SecretVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. func (o SecretVolumeSourcePatchOutput) DefaultMode() pulumi.IntPtrOutput { return o.ApplyT(func(v SecretVolumeSourcePatch) *int { return v.DefaultMode }).(pulumi.IntPtrOutput) @@ -58527,6 +66046,12 @@ func (o SecretVolumeSourcePatchPtrOutput) ToSecretVolumeSourcePatchPtrOutputWith return o } +func (o SecretVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretVolumeSourcePatch] { + return pulumix.Output[*SecretVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o SecretVolumeSourcePatchPtrOutput) Elem() SecretVolumeSourcePatchOutput { return o.ApplyT(func(v *SecretVolumeSourcePatch) SecretVolumeSourcePatch { if v != nil { @@ -58652,6 +66177,12 @@ func (i SecurityContextArgs) ToSecurityContextOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SecurityContextOutput) } +func (i SecurityContextArgs) ToOutput(ctx context.Context) pulumix.Output[SecurityContext] { + return pulumix.Output[SecurityContext]{ + OutputState: i.ToSecurityContextOutputWithContext(ctx).OutputState, + } +} + func (i SecurityContextArgs) ToSecurityContextPtrOutput() SecurityContextPtrOutput { return i.ToSecurityContextPtrOutputWithContext(context.Background()) } @@ -58693,6 +66224,12 @@ func (i *securityContextPtrType) ToSecurityContextPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(SecurityContextPtrOutput) } +func (i *securityContextPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecurityContext] { + return pulumix.Output[*SecurityContext]{ + OutputState: i.ToSecurityContextPtrOutputWithContext(ctx).OutputState, + } +} + // SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence. type SecurityContextOutput struct{ *pulumi.OutputState } @@ -58718,6 +66255,12 @@ func (o SecurityContextOutput) ToSecurityContextPtrOutputWithContext(ctx context }).(SecurityContextPtrOutput) } +func (o SecurityContextOutput) ToOutput(ctx context.Context) pulumix.Output[SecurityContext] { + return pulumix.Output[SecurityContext]{ + OutputState: o.OutputState, + } +} + // AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. func (o SecurityContextOutput) AllowPrivilegeEscalation() pulumi.BoolPtrOutput { return o.ApplyT(func(v SecurityContext) *bool { return v.AllowPrivilegeEscalation }).(pulumi.BoolPtrOutput) @@ -58787,6 +66330,12 @@ func (o SecurityContextPtrOutput) ToSecurityContextPtrOutputWithContext(ctx cont return o } +func (o SecurityContextPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecurityContext] { + return pulumix.Output[*SecurityContext]{ + OutputState: o.OutputState, + } +} + func (o SecurityContextPtrOutput) Elem() SecurityContextOutput { return o.ApplyT(func(v *SecurityContext) SecurityContext { if v != nil { @@ -58982,6 +66531,12 @@ func (i SecurityContextPatchArgs) ToSecurityContextPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(SecurityContextPatchOutput) } +func (i SecurityContextPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SecurityContextPatch] { + return pulumix.Output[SecurityContextPatch]{ + OutputState: i.ToSecurityContextPatchOutputWithContext(ctx).OutputState, + } +} + func (i SecurityContextPatchArgs) ToSecurityContextPatchPtrOutput() SecurityContextPatchPtrOutput { return i.ToSecurityContextPatchPtrOutputWithContext(context.Background()) } @@ -59023,6 +66578,12 @@ func (i *securityContextPatchPtrType) ToSecurityContextPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(SecurityContextPatchPtrOutput) } +func (i *securityContextPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SecurityContextPatch] { + return pulumix.Output[*SecurityContextPatch]{ + OutputState: i.ToSecurityContextPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence. type SecurityContextPatchOutput struct{ *pulumi.OutputState } @@ -59048,6 +66609,12 @@ func (o SecurityContextPatchOutput) ToSecurityContextPatchPtrOutputWithContext(c }).(SecurityContextPatchPtrOutput) } +func (o SecurityContextPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SecurityContextPatch] { + return pulumix.Output[SecurityContextPatch]{ + OutputState: o.OutputState, + } +} + // AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. func (o SecurityContextPatchOutput) AllowPrivilegeEscalation() pulumi.BoolPtrOutput { return o.ApplyT(func(v SecurityContextPatch) *bool { return v.AllowPrivilegeEscalation }).(pulumi.BoolPtrOutput) @@ -59117,6 +66684,12 @@ func (o SecurityContextPatchPtrOutput) ToSecurityContextPatchPtrOutputWithContex return o } +func (o SecurityContextPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SecurityContextPatch] { + return pulumix.Output[*SecurityContextPatch]{ + OutputState: o.OutputState, + } +} + func (o SecurityContextPatchPtrOutput) Elem() SecurityContextPatchOutput { return o.ApplyT(func(v *SecurityContextPatch) SecurityContextPatch { if v != nil { @@ -59338,6 +66911,12 @@ func (i ServiceTypeArgs) ToServiceTypeOutputWithContext(ctx context.Context) Ser return pulumi.ToOutputWithContext(ctx, i).(ServiceTypeOutput) } +func (i ServiceTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceType] { + return pulumix.Output[ServiceType]{ + OutputState: i.ToServiceTypeOutputWithContext(ctx).OutputState, + } +} + // ServiceTypeArrayInput is an input type that accepts ServiceTypeArray and ServiceTypeArrayOutput values. // You can construct a concrete instance of `ServiceTypeArrayInput` via: // @@ -59363,6 +66942,12 @@ func (i ServiceTypeArray) ToServiceTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ServiceTypeArrayOutput) } +func (i ServiceTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ServiceType] { + return pulumix.Output[[]ServiceType]{ + OutputState: i.ToServiceTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy. // // This resource waits until its status is ready before registering success @@ -59403,6 +66988,12 @@ func (o ServiceTypeOutput) ToServiceTypeOutputWithContext(ctx context.Context) S return o } +func (o ServiceTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceType] { + return pulumix.Output[ServiceType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -59442,6 +67033,12 @@ func (o ServiceTypeArrayOutput) ToServiceTypeArrayOutputWithContext(ctx context. return o } +func (o ServiceTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ServiceType] { + return pulumix.Output[[]ServiceType]{ + OutputState: o.OutputState, + } +} + func (o ServiceTypeArrayOutput) Index(i pulumi.IntInput) ServiceTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceType { return vs[0].([]ServiceType)[vs[1].(int)] @@ -59503,6 +67100,12 @@ func (i ServiceAccountTypeArgs) ToServiceAccountTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountTypeOutput) } +func (i ServiceAccountTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountType] { + return pulumix.Output[ServiceAccountType]{ + OutputState: i.ToServiceAccountTypeOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountTypeArrayInput is an input type that accepts ServiceAccountTypeArray and ServiceAccountTypeArrayOutput values. // You can construct a concrete instance of `ServiceAccountTypeArrayInput` via: // @@ -59528,6 +67131,12 @@ func (i ServiceAccountTypeArray) ToServiceAccountTypeArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountTypeArrayOutput) } +func (i ServiceAccountTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ServiceAccountType] { + return pulumix.Output[[]ServiceAccountType]{ + OutputState: i.ToServiceAccountTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets type ServiceAccountTypeOutput struct{ *pulumi.OutputState } @@ -59543,6 +67152,12 @@ func (o ServiceAccountTypeOutput) ToServiceAccountTypeOutputWithContext(ctx cont return o } +func (o ServiceAccountTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountType] { + return pulumix.Output[ServiceAccountType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceAccountTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -59587,6 +67202,12 @@ func (o ServiceAccountTypeArrayOutput) ToServiceAccountTypeArrayOutputWithContex return o } +func (o ServiceAccountTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ServiceAccountType] { + return pulumix.Output[[]ServiceAccountType]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountTypeArrayOutput) Index(i pulumi.IntInput) ServiceAccountTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceAccountType { return vs[0].([]ServiceAccountType)[vs[1].(int)] @@ -59640,6 +67261,12 @@ func (i ServiceAccountListTypeArgs) ToServiceAccountListTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountListTypeOutput) } +func (i ServiceAccountListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountListType] { + return pulumix.Output[ServiceAccountListType]{ + OutputState: i.ToServiceAccountListTypeOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountList is a list of ServiceAccount objects type ServiceAccountListTypeOutput struct{ *pulumi.OutputState } @@ -59655,6 +67282,12 @@ func (o ServiceAccountListTypeOutput) ToServiceAccountListTypeOutputWithContext( return o } +func (o ServiceAccountListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountListType] { + return pulumix.Output[ServiceAccountListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceAccountListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -59730,6 +67363,12 @@ func (i ServiceAccountPatchTypeArgs) ToServiceAccountPatchTypeOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountPatchTypeOutput) } +func (i ServiceAccountPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountPatchType] { + return pulumix.Output[ServiceAccountPatchType]{ + OutputState: i.ToServiceAccountPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets type ServiceAccountPatchTypeOutput struct{ *pulumi.OutputState } @@ -59745,6 +67384,12 @@ func (o ServiceAccountPatchTypeOutput) ToServiceAccountPatchTypeOutputWithContex return o } +func (o ServiceAccountPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountPatchType] { + return pulumix.Output[ServiceAccountPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceAccountPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -59818,6 +67463,12 @@ func (i ServiceAccountTokenProjectionArgs) ToServiceAccountTokenProjectionOutput return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountTokenProjectionOutput) } +func (i ServiceAccountTokenProjectionArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountTokenProjection] { + return pulumix.Output[ServiceAccountTokenProjection]{ + OutputState: i.ToServiceAccountTokenProjectionOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountTokenProjectionArgs) ToServiceAccountTokenProjectionPtrOutput() ServiceAccountTokenProjectionPtrOutput { return i.ToServiceAccountTokenProjectionPtrOutputWithContext(context.Background()) } @@ -59859,6 +67510,12 @@ func (i *serviceAccountTokenProjectionPtrType) ToServiceAccountTokenProjectionPt return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountTokenProjectionPtrOutput) } +func (i *serviceAccountTokenProjectionPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountTokenProjection] { + return pulumix.Output[*ServiceAccountTokenProjection]{ + OutputState: i.ToServiceAccountTokenProjectionPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise). type ServiceAccountTokenProjectionOutput struct{ *pulumi.OutputState } @@ -59884,6 +67541,12 @@ func (o ServiceAccountTokenProjectionOutput) ToServiceAccountTokenProjectionPtrO }).(ServiceAccountTokenProjectionPtrOutput) } +func (o ServiceAccountTokenProjectionOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountTokenProjection] { + return pulumix.Output[ServiceAccountTokenProjection]{ + OutputState: o.OutputState, + } +} + // audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver. func (o ServiceAccountTokenProjectionOutput) Audience() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountTokenProjection) *string { return v.Audience }).(pulumi.StringPtrOutput) @@ -59913,6 +67576,12 @@ func (o ServiceAccountTokenProjectionPtrOutput) ToServiceAccountTokenProjectionP return o } +func (o ServiceAccountTokenProjectionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountTokenProjection] { + return pulumix.Output[*ServiceAccountTokenProjection]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountTokenProjectionPtrOutput) Elem() ServiceAccountTokenProjectionOutput { return o.ApplyT(func(v *ServiceAccountTokenProjection) ServiceAccountTokenProjection { if v != nil { @@ -59996,6 +67665,12 @@ func (i ServiceAccountTokenProjectionPatchArgs) ToServiceAccountTokenProjectionP return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountTokenProjectionPatchOutput) } +func (i ServiceAccountTokenProjectionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountTokenProjectionPatch] { + return pulumix.Output[ServiceAccountTokenProjectionPatch]{ + OutputState: i.ToServiceAccountTokenProjectionPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountTokenProjectionPatchArgs) ToServiceAccountTokenProjectionPatchPtrOutput() ServiceAccountTokenProjectionPatchPtrOutput { return i.ToServiceAccountTokenProjectionPatchPtrOutputWithContext(context.Background()) } @@ -60037,6 +67712,12 @@ func (i *serviceAccountTokenProjectionPatchPtrType) ToServiceAccountTokenProject return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountTokenProjectionPatchPtrOutput) } +func (i *serviceAccountTokenProjectionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountTokenProjectionPatch] { + return pulumix.Output[*ServiceAccountTokenProjectionPatch]{ + OutputState: i.ToServiceAccountTokenProjectionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise). type ServiceAccountTokenProjectionPatchOutput struct{ *pulumi.OutputState } @@ -60062,6 +67743,12 @@ func (o ServiceAccountTokenProjectionPatchOutput) ToServiceAccountTokenProjectio }).(ServiceAccountTokenProjectionPatchPtrOutput) } +func (o ServiceAccountTokenProjectionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountTokenProjectionPatch] { + return pulumix.Output[ServiceAccountTokenProjectionPatch]{ + OutputState: o.OutputState, + } +} + // audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver. func (o ServiceAccountTokenProjectionPatchOutput) Audience() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountTokenProjectionPatch) *string { return v.Audience }).(pulumi.StringPtrOutput) @@ -60091,6 +67778,12 @@ func (o ServiceAccountTokenProjectionPatchPtrOutput) ToServiceAccountTokenProjec return o } +func (o ServiceAccountTokenProjectionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountTokenProjectionPatch] { + return pulumix.Output[*ServiceAccountTokenProjectionPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountTokenProjectionPatchPtrOutput) Elem() ServiceAccountTokenProjectionPatchOutput { return o.ApplyT(func(v *ServiceAccountTokenProjectionPatch) ServiceAccountTokenProjectionPatch { if v != nil { @@ -60178,6 +67871,12 @@ func (i ServiceListTypeArgs) ToServiceListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ServiceListTypeOutput) } +func (i ServiceListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceListType] { + return pulumix.Output[ServiceListType]{ + OutputState: i.ToServiceListTypeOutputWithContext(ctx).OutputState, + } +} + // ServiceList holds a list of services. type ServiceListTypeOutput struct{ *pulumi.OutputState } @@ -60193,6 +67892,12 @@ func (o ServiceListTypeOutput) ToServiceListTypeOutputWithContext(ctx context.Co return o } +func (o ServiceListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceListType] { + return pulumix.Output[ServiceListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -60314,6 +68019,12 @@ func (i ServicePatchTypeArgs) ToServicePatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServicePatchTypeOutput) } +func (i ServicePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ServicePatchType] { + return pulumix.Output[ServicePatchType]{ + OutputState: i.ToServicePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy. // // This resource waits until its status is ready before registering success @@ -60354,6 +68065,12 @@ func (o ServicePatchTypeOutput) ToServicePatchTypeOutputWithContext(ctx context. return o } +func (o ServicePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ServicePatchType] { + return pulumix.Output[ServicePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServicePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ServicePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -60452,6 +68169,12 @@ func (i ServicePortArgs) ToServicePortOutputWithContext(ctx context.Context) Ser return pulumi.ToOutputWithContext(ctx, i).(ServicePortOutput) } +func (i ServicePortArgs) ToOutput(ctx context.Context) pulumix.Output[ServicePort] { + return pulumix.Output[ServicePort]{ + OutputState: i.ToServicePortOutputWithContext(ctx).OutputState, + } +} + // ServicePortArrayInput is an input type that accepts ServicePortArray and ServicePortArrayOutput values. // You can construct a concrete instance of `ServicePortArrayInput` via: // @@ -60477,6 +68200,12 @@ func (i ServicePortArray) ToServicePortArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ServicePortArrayOutput) } +func (i ServicePortArray) ToOutput(ctx context.Context) pulumix.Output[[]ServicePort] { + return pulumix.Output[[]ServicePort]{ + OutputState: i.ToServicePortArrayOutputWithContext(ctx).OutputState, + } +} + // ServicePort contains information on service's port. type ServicePortOutput struct{ *pulumi.OutputState } @@ -60492,6 +68221,12 @@ func (o ServicePortOutput) ToServicePortOutputWithContext(ctx context.Context) S return o } +func (o ServicePortOutput) ToOutput(ctx context.Context) pulumix.Output[ServicePort] { + return pulumix.Output[ServicePort]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either: // // * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). @@ -60545,6 +68280,12 @@ func (o ServicePortArrayOutput) ToServicePortArrayOutputWithContext(ctx context. return o } +func (o ServicePortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ServicePort] { + return pulumix.Output[[]ServicePort]{ + OutputState: o.OutputState, + } +} + func (o ServicePortArrayOutput) Index(i pulumi.IntInput) ServicePortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServicePort { return vs[0].([]ServicePort)[vs[1].(int)] @@ -60624,6 +68365,12 @@ func (i ServicePortPatchArgs) ToServicePortPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServicePortPatchOutput) } +func (i ServicePortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServicePortPatch] { + return pulumix.Output[ServicePortPatch]{ + OutputState: i.ToServicePortPatchOutputWithContext(ctx).OutputState, + } +} + // ServicePortPatchArrayInput is an input type that accepts ServicePortPatchArray and ServicePortPatchArrayOutput values. // You can construct a concrete instance of `ServicePortPatchArrayInput` via: // @@ -60649,6 +68396,12 @@ func (i ServicePortPatchArray) ToServicePortPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ServicePortPatchArrayOutput) } +func (i ServicePortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ServicePortPatch] { + return pulumix.Output[[]ServicePortPatch]{ + OutputState: i.ToServicePortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ServicePort contains information on service's port. type ServicePortPatchOutput struct{ *pulumi.OutputState } @@ -60664,6 +68417,12 @@ func (o ServicePortPatchOutput) ToServicePortPatchOutputWithContext(ctx context. return o } +func (o ServicePortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServicePortPatch] { + return pulumix.Output[ServicePortPatch]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either: // // * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). @@ -60717,6 +68476,12 @@ func (o ServicePortPatchArrayOutput) ToServicePortPatchArrayOutputWithContext(ct return o } +func (o ServicePortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ServicePortPatch] { + return pulumix.Output[[]ServicePortPatch]{ + OutputState: o.OutputState, + } +} + func (o ServicePortPatchArrayOutput) Index(i pulumi.IntInput) ServicePortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServicePortPatch { return vs[0].([]ServicePortPatch)[vs[1].(int)] @@ -60846,6 +68611,12 @@ func (i ServiceSpecArgs) ToServiceSpecOutputWithContext(ctx context.Context) Ser return pulumi.ToOutputWithContext(ctx, i).(ServiceSpecOutput) } +func (i ServiceSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceSpec] { + return pulumix.Output[ServiceSpec]{ + OutputState: i.ToServiceSpecOutputWithContext(ctx).OutputState, + } +} + func (i ServiceSpecArgs) ToServiceSpecPtrOutput() ServiceSpecPtrOutput { return i.ToServiceSpecPtrOutputWithContext(context.Background()) } @@ -60887,6 +68658,12 @@ func (i *serviceSpecPtrType) ToServiceSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ServiceSpecPtrOutput) } +func (i *serviceSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceSpec] { + return pulumix.Output[*ServiceSpec]{ + OutputState: i.ToServiceSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceSpec describes the attributes that a user creates on a service. type ServiceSpecOutput struct{ *pulumi.OutputState } @@ -60912,6 +68689,12 @@ func (o ServiceSpecOutput) ToServiceSpecPtrOutputWithContext(ctx context.Context }).(ServiceSpecPtrOutput) } +func (o ServiceSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceSpec] { + return pulumix.Output[ServiceSpec]{ + OutputState: o.OutputState, + } +} + // allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is "true". It may be set to "false" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type. func (o ServiceSpecOutput) AllocateLoadBalancerNodePorts() pulumi.BoolPtrOutput { return o.ApplyT(func(v ServiceSpec) *bool { return v.AllocateLoadBalancerNodePorts }).(pulumi.BoolPtrOutput) @@ -61035,6 +68818,12 @@ func (o ServiceSpecPtrOutput) ToServiceSpecPtrOutputWithContext(ctx context.Cont return o } +func (o ServiceSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceSpec] { + return pulumix.Output[*ServiceSpec]{ + OutputState: o.OutputState, + } +} + func (o ServiceSpecPtrOutput) Elem() ServiceSpecOutput { return o.ApplyT(func(v *ServiceSpec) ServiceSpec { if v != nil { @@ -61382,6 +69171,12 @@ func (i ServiceSpecPatchArgs) ToServiceSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ServiceSpecPatchOutput) } +func (i ServiceSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceSpecPatch] { + return pulumix.Output[ServiceSpecPatch]{ + OutputState: i.ToServiceSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceSpecPatchArgs) ToServiceSpecPatchPtrOutput() ServiceSpecPatchPtrOutput { return i.ToServiceSpecPatchPtrOutputWithContext(context.Background()) } @@ -61423,6 +69218,12 @@ func (i *serviceSpecPatchPtrType) ToServiceSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ServiceSpecPatchPtrOutput) } +func (i *serviceSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceSpecPatch] { + return pulumix.Output[*ServiceSpecPatch]{ + OutputState: i.ToServiceSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceSpec describes the attributes that a user creates on a service. type ServiceSpecPatchOutput struct{ *pulumi.OutputState } @@ -61448,6 +69249,12 @@ func (o ServiceSpecPatchOutput) ToServiceSpecPatchPtrOutputWithContext(ctx conte }).(ServiceSpecPatchPtrOutput) } +func (o ServiceSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceSpecPatch] { + return pulumix.Output[ServiceSpecPatch]{ + OutputState: o.OutputState, + } +} + // allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is "true". It may be set to "false" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type. func (o ServiceSpecPatchOutput) AllocateLoadBalancerNodePorts() pulumi.BoolPtrOutput { return o.ApplyT(func(v ServiceSpecPatch) *bool { return v.AllocateLoadBalancerNodePorts }).(pulumi.BoolPtrOutput) @@ -61571,6 +69378,12 @@ func (o ServiceSpecPatchPtrOutput) ToServiceSpecPatchPtrOutputWithContext(ctx co return o } +func (o ServiceSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceSpecPatch] { + return pulumix.Output[*ServiceSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceSpecPatchPtrOutput) Elem() ServiceSpecPatchOutput { return o.ApplyT(func(v *ServiceSpecPatch) ServiceSpecPatch { if v != nil { @@ -61834,6 +69647,12 @@ func (i ServiceStatusArgs) ToServiceStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ServiceStatusOutput) } +func (i ServiceStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceStatus] { + return pulumix.Output[ServiceStatus]{ + OutputState: i.ToServiceStatusOutputWithContext(ctx).OutputState, + } +} + func (i ServiceStatusArgs) ToServiceStatusPtrOutput() ServiceStatusPtrOutput { return i.ToServiceStatusPtrOutputWithContext(context.Background()) } @@ -61875,6 +69694,12 @@ func (i *serviceStatusPtrType) ToServiceStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ServiceStatusPtrOutput) } +func (i *serviceStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceStatus] { + return pulumix.Output[*ServiceStatus]{ + OutputState: i.ToServiceStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceStatus represents the current status of a service. type ServiceStatusOutput struct{ *pulumi.OutputState } @@ -61900,6 +69725,12 @@ func (o ServiceStatusOutput) ToServiceStatusPtrOutputWithContext(ctx context.Con }).(ServiceStatusPtrOutput) } +func (o ServiceStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceStatus] { + return pulumix.Output[ServiceStatus]{ + OutputState: o.OutputState, + } +} + // Current service state func (o ServiceStatusOutput) Conditions() metav1.ConditionArrayOutput { return o.ApplyT(func(v ServiceStatus) []metav1.Condition { return v.Conditions }).(metav1.ConditionArrayOutput) @@ -61924,6 +69755,12 @@ func (o ServiceStatusPtrOutput) ToServiceStatusPtrOutputWithContext(ctx context. return o } +func (o ServiceStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceStatus] { + return pulumix.Output[*ServiceStatus]{ + OutputState: o.OutputState, + } +} + func (o ServiceStatusPtrOutput) Elem() ServiceStatusOutput { return o.ApplyT(func(v *ServiceStatus) ServiceStatus { if v != nil { @@ -61993,6 +69830,12 @@ func (i ServiceStatusPatchArgs) ToServiceStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ServiceStatusPatchOutput) } +func (i ServiceStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceStatusPatch] { + return pulumix.Output[ServiceStatusPatch]{ + OutputState: i.ToServiceStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceStatusPatchArgs) ToServiceStatusPatchPtrOutput() ServiceStatusPatchPtrOutput { return i.ToServiceStatusPatchPtrOutputWithContext(context.Background()) } @@ -62034,6 +69877,12 @@ func (i *serviceStatusPatchPtrType) ToServiceStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceStatusPatchPtrOutput) } +func (i *serviceStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceStatusPatch] { + return pulumix.Output[*ServiceStatusPatch]{ + OutputState: i.ToServiceStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceStatus represents the current status of a service. type ServiceStatusPatchOutput struct{ *pulumi.OutputState } @@ -62059,6 +69908,12 @@ func (o ServiceStatusPatchOutput) ToServiceStatusPatchPtrOutputWithContext(ctx c }).(ServiceStatusPatchPtrOutput) } +func (o ServiceStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceStatusPatch] { + return pulumix.Output[ServiceStatusPatch]{ + OutputState: o.OutputState, + } +} + // Current service state func (o ServiceStatusPatchOutput) Conditions() metav1.ConditionPatchArrayOutput { return o.ApplyT(func(v ServiceStatusPatch) []metav1.ConditionPatch { return v.Conditions }).(metav1.ConditionPatchArrayOutput) @@ -62083,6 +69938,12 @@ func (o ServiceStatusPatchPtrOutput) ToServiceStatusPatchPtrOutputWithContext(ct return o } +func (o ServiceStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceStatusPatch] { + return pulumix.Output[*ServiceStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceStatusPatchPtrOutput) Elem() ServiceStatusPatchOutput { return o.ApplyT(func(v *ServiceStatusPatch) ServiceStatusPatch { if v != nil { @@ -62148,6 +70009,12 @@ func (i SessionAffinityConfigArgs) ToSessionAffinityConfigOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(SessionAffinityConfigOutput) } +func (i SessionAffinityConfigArgs) ToOutput(ctx context.Context) pulumix.Output[SessionAffinityConfig] { + return pulumix.Output[SessionAffinityConfig]{ + OutputState: i.ToSessionAffinityConfigOutputWithContext(ctx).OutputState, + } +} + func (i SessionAffinityConfigArgs) ToSessionAffinityConfigPtrOutput() SessionAffinityConfigPtrOutput { return i.ToSessionAffinityConfigPtrOutputWithContext(context.Background()) } @@ -62189,6 +70056,12 @@ func (i *sessionAffinityConfigPtrType) ToSessionAffinityConfigPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(SessionAffinityConfigPtrOutput) } +func (i *sessionAffinityConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*SessionAffinityConfig] { + return pulumix.Output[*SessionAffinityConfig]{ + OutputState: i.ToSessionAffinityConfigPtrOutputWithContext(ctx).OutputState, + } +} + // SessionAffinityConfig represents the configurations of session affinity. type SessionAffinityConfigOutput struct{ *pulumi.OutputState } @@ -62214,6 +70087,12 @@ func (o SessionAffinityConfigOutput) ToSessionAffinityConfigPtrOutputWithContext }).(SessionAffinityConfigPtrOutput) } +func (o SessionAffinityConfigOutput) ToOutput(ctx context.Context) pulumix.Output[SessionAffinityConfig] { + return pulumix.Output[SessionAffinityConfig]{ + OutputState: o.OutputState, + } +} + // clientIP contains the configurations of Client IP based session affinity. func (o SessionAffinityConfigOutput) ClientIP() ClientIPConfigPtrOutput { return o.ApplyT(func(v SessionAffinityConfig) *ClientIPConfig { return v.ClientIP }).(ClientIPConfigPtrOutput) @@ -62233,6 +70112,12 @@ func (o SessionAffinityConfigPtrOutput) ToSessionAffinityConfigPtrOutputWithCont return o } +func (o SessionAffinityConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SessionAffinityConfig] { + return pulumix.Output[*SessionAffinityConfig]{ + OutputState: o.OutputState, + } +} + func (o SessionAffinityConfigPtrOutput) Elem() SessionAffinityConfigOutput { return o.ApplyT(func(v *SessionAffinityConfig) SessionAffinityConfig { if v != nil { @@ -62288,6 +70173,12 @@ func (i SessionAffinityConfigPatchArgs) ToSessionAffinityConfigPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(SessionAffinityConfigPatchOutput) } +func (i SessionAffinityConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SessionAffinityConfigPatch] { + return pulumix.Output[SessionAffinityConfigPatch]{ + OutputState: i.ToSessionAffinityConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i SessionAffinityConfigPatchArgs) ToSessionAffinityConfigPatchPtrOutput() SessionAffinityConfigPatchPtrOutput { return i.ToSessionAffinityConfigPatchPtrOutputWithContext(context.Background()) } @@ -62329,6 +70220,12 @@ func (i *sessionAffinityConfigPatchPtrType) ToSessionAffinityConfigPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(SessionAffinityConfigPatchPtrOutput) } +func (i *sessionAffinityConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SessionAffinityConfigPatch] { + return pulumix.Output[*SessionAffinityConfigPatch]{ + OutputState: i.ToSessionAffinityConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SessionAffinityConfig represents the configurations of session affinity. type SessionAffinityConfigPatchOutput struct{ *pulumi.OutputState } @@ -62354,6 +70251,12 @@ func (o SessionAffinityConfigPatchOutput) ToSessionAffinityConfigPatchPtrOutputW }).(SessionAffinityConfigPatchPtrOutput) } +func (o SessionAffinityConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SessionAffinityConfigPatch] { + return pulumix.Output[SessionAffinityConfigPatch]{ + OutputState: o.OutputState, + } +} + // clientIP contains the configurations of Client IP based session affinity. func (o SessionAffinityConfigPatchOutput) ClientIP() ClientIPConfigPatchPtrOutput { return o.ApplyT(func(v SessionAffinityConfigPatch) *ClientIPConfigPatch { return v.ClientIP }).(ClientIPConfigPatchPtrOutput) @@ -62373,6 +70276,12 @@ func (o SessionAffinityConfigPatchPtrOutput) ToSessionAffinityConfigPatchPtrOutp return o } +func (o SessionAffinityConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SessionAffinityConfigPatch] { + return pulumix.Output[*SessionAffinityConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o SessionAffinityConfigPatchPtrOutput) Elem() SessionAffinityConfigPatchOutput { return o.ApplyT(func(v *SessionAffinityConfigPatch) SessionAffinityConfigPatch { if v != nil { @@ -62444,6 +70353,12 @@ func (i StorageOSPersistentVolumeSourceArgs) ToStorageOSPersistentVolumeSourceOu return pulumi.ToOutputWithContext(ctx, i).(StorageOSPersistentVolumeSourceOutput) } +func (i StorageOSPersistentVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[StorageOSPersistentVolumeSource] { + return pulumix.Output[StorageOSPersistentVolumeSource]{ + OutputState: i.ToStorageOSPersistentVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i StorageOSPersistentVolumeSourceArgs) ToStorageOSPersistentVolumeSourcePtrOutput() StorageOSPersistentVolumeSourcePtrOutput { return i.ToStorageOSPersistentVolumeSourcePtrOutputWithContext(context.Background()) } @@ -62485,6 +70400,12 @@ func (i *storageOSPersistentVolumeSourcePtrType) ToStorageOSPersistentVolumeSour return pulumi.ToOutputWithContext(ctx, i).(StorageOSPersistentVolumeSourcePtrOutput) } +func (i *storageOSPersistentVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*StorageOSPersistentVolumeSource] { + return pulumix.Output[*StorageOSPersistentVolumeSource]{ + OutputState: i.ToStorageOSPersistentVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a StorageOS persistent volume resource. type StorageOSPersistentVolumeSourceOutput struct{ *pulumi.OutputState } @@ -62510,6 +70431,12 @@ func (o StorageOSPersistentVolumeSourceOutput) ToStorageOSPersistentVolumeSource }).(StorageOSPersistentVolumeSourcePtrOutput) } +func (o StorageOSPersistentVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[StorageOSPersistentVolumeSource] { + return pulumix.Output[StorageOSPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o StorageOSPersistentVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v StorageOSPersistentVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -62549,6 +70476,12 @@ func (o StorageOSPersistentVolumeSourcePtrOutput) ToStorageOSPersistentVolumeSou return o } +func (o StorageOSPersistentVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageOSPersistentVolumeSource] { + return pulumix.Output[*StorageOSPersistentVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o StorageOSPersistentVolumeSourcePtrOutput) Elem() StorageOSPersistentVolumeSourceOutput { return o.ApplyT(func(v *StorageOSPersistentVolumeSource) StorageOSPersistentVolumeSource { if v != nil { @@ -62660,6 +70593,12 @@ func (i StorageOSPersistentVolumeSourcePatchArgs) ToStorageOSPersistentVolumeSou return pulumi.ToOutputWithContext(ctx, i).(StorageOSPersistentVolumeSourcePatchOutput) } +func (i StorageOSPersistentVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[StorageOSPersistentVolumeSourcePatch] { + return pulumix.Output[StorageOSPersistentVolumeSourcePatch]{ + OutputState: i.ToStorageOSPersistentVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i StorageOSPersistentVolumeSourcePatchArgs) ToStorageOSPersistentVolumeSourcePatchPtrOutput() StorageOSPersistentVolumeSourcePatchPtrOutput { return i.ToStorageOSPersistentVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -62701,6 +70640,12 @@ func (i *storageOSPersistentVolumeSourcePatchPtrType) ToStorageOSPersistentVolum return pulumi.ToOutputWithContext(ctx, i).(StorageOSPersistentVolumeSourcePatchPtrOutput) } +func (i *storageOSPersistentVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StorageOSPersistentVolumeSourcePatch] { + return pulumix.Output[*StorageOSPersistentVolumeSourcePatch]{ + OutputState: i.ToStorageOSPersistentVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a StorageOS persistent volume resource. type StorageOSPersistentVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -62726,6 +70671,12 @@ func (o StorageOSPersistentVolumeSourcePatchOutput) ToStorageOSPersistentVolumeS }).(StorageOSPersistentVolumeSourcePatchPtrOutput) } +func (o StorageOSPersistentVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[StorageOSPersistentVolumeSourcePatch] { + return pulumix.Output[StorageOSPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o StorageOSPersistentVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v StorageOSPersistentVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -62765,6 +70716,12 @@ func (o StorageOSPersistentVolumeSourcePatchPtrOutput) ToStorageOSPersistentVolu return o } +func (o StorageOSPersistentVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageOSPersistentVolumeSourcePatch] { + return pulumix.Output[*StorageOSPersistentVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o StorageOSPersistentVolumeSourcePatchPtrOutput) Elem() StorageOSPersistentVolumeSourcePatchOutput { return o.ApplyT(func(v *StorageOSPersistentVolumeSourcePatch) StorageOSPersistentVolumeSourcePatch { if v != nil { @@ -62876,6 +70833,12 @@ func (i StorageOSVolumeSourceArgs) ToStorageOSVolumeSourceOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(StorageOSVolumeSourceOutput) } +func (i StorageOSVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[StorageOSVolumeSource] { + return pulumix.Output[StorageOSVolumeSource]{ + OutputState: i.ToStorageOSVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i StorageOSVolumeSourceArgs) ToStorageOSVolumeSourcePtrOutput() StorageOSVolumeSourcePtrOutput { return i.ToStorageOSVolumeSourcePtrOutputWithContext(context.Background()) } @@ -62917,6 +70880,12 @@ func (i *storageOSVolumeSourcePtrType) ToStorageOSVolumeSourcePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(StorageOSVolumeSourcePtrOutput) } +func (i *storageOSVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*StorageOSVolumeSource] { + return pulumix.Output[*StorageOSVolumeSource]{ + OutputState: i.ToStorageOSVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a StorageOS persistent volume resource. type StorageOSVolumeSourceOutput struct{ *pulumi.OutputState } @@ -62942,6 +70911,12 @@ func (o StorageOSVolumeSourceOutput) ToStorageOSVolumeSourcePtrOutputWithContext }).(StorageOSVolumeSourcePtrOutput) } +func (o StorageOSVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[StorageOSVolumeSource] { + return pulumix.Output[StorageOSVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o StorageOSVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v StorageOSVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -62981,6 +70956,12 @@ func (o StorageOSVolumeSourcePtrOutput) ToStorageOSVolumeSourcePtrOutputWithCont return o } +func (o StorageOSVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageOSVolumeSource] { + return pulumix.Output[*StorageOSVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o StorageOSVolumeSourcePtrOutput) Elem() StorageOSVolumeSourceOutput { return o.ApplyT(func(v *StorageOSVolumeSource) StorageOSVolumeSource { if v != nil { @@ -63092,6 +71073,12 @@ func (i StorageOSVolumeSourcePatchArgs) ToStorageOSVolumeSourcePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(StorageOSVolumeSourcePatchOutput) } +func (i StorageOSVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[StorageOSVolumeSourcePatch] { + return pulumix.Output[StorageOSVolumeSourcePatch]{ + OutputState: i.ToStorageOSVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i StorageOSVolumeSourcePatchArgs) ToStorageOSVolumeSourcePatchPtrOutput() StorageOSVolumeSourcePatchPtrOutput { return i.ToStorageOSVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -63133,6 +71120,12 @@ func (i *storageOSVolumeSourcePatchPtrType) ToStorageOSVolumeSourcePatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(StorageOSVolumeSourcePatchPtrOutput) } +func (i *storageOSVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StorageOSVolumeSourcePatch] { + return pulumix.Output[*StorageOSVolumeSourcePatch]{ + OutputState: i.ToStorageOSVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a StorageOS persistent volume resource. type StorageOSVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -63158,6 +71151,12 @@ func (o StorageOSVolumeSourcePatchOutput) ToStorageOSVolumeSourcePatchPtrOutputW }).(StorageOSVolumeSourcePatchPtrOutput) } +func (o StorageOSVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[StorageOSVolumeSourcePatch] { + return pulumix.Output[StorageOSVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o StorageOSVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v StorageOSVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -63197,6 +71196,12 @@ func (o StorageOSVolumeSourcePatchPtrOutput) ToStorageOSVolumeSourcePatchPtrOutp return o } +func (o StorageOSVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageOSVolumeSourcePatch] { + return pulumix.Output[*StorageOSVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o StorageOSVolumeSourcePatchPtrOutput) Elem() StorageOSVolumeSourcePatchOutput { return o.ApplyT(func(v *StorageOSVolumeSourcePatch) StorageOSVolumeSourcePatch { if v != nil { @@ -63296,6 +71301,12 @@ func (i SysctlArgs) ToSysctlOutputWithContext(ctx context.Context) SysctlOutput return pulumi.ToOutputWithContext(ctx, i).(SysctlOutput) } +func (i SysctlArgs) ToOutput(ctx context.Context) pulumix.Output[Sysctl] { + return pulumix.Output[Sysctl]{ + OutputState: i.ToSysctlOutputWithContext(ctx).OutputState, + } +} + // SysctlArrayInput is an input type that accepts SysctlArray and SysctlArrayOutput values. // You can construct a concrete instance of `SysctlArrayInput` via: // @@ -63321,6 +71332,12 @@ func (i SysctlArray) ToSysctlArrayOutputWithContext(ctx context.Context) SysctlA return pulumi.ToOutputWithContext(ctx, i).(SysctlArrayOutput) } +func (i SysctlArray) ToOutput(ctx context.Context) pulumix.Output[[]Sysctl] { + return pulumix.Output[[]Sysctl]{ + OutputState: i.ToSysctlArrayOutputWithContext(ctx).OutputState, + } +} + // Sysctl defines a kernel parameter to be set type SysctlOutput struct{ *pulumi.OutputState } @@ -63336,6 +71353,12 @@ func (o SysctlOutput) ToSysctlOutputWithContext(ctx context.Context) SysctlOutpu return o } +func (o SysctlOutput) ToOutput(ctx context.Context) pulumix.Output[Sysctl] { + return pulumix.Output[Sysctl]{ + OutputState: o.OutputState, + } +} + // Name of a property to set func (o SysctlOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v Sysctl) string { return v.Name }).(pulumi.StringOutput) @@ -63360,6 +71383,12 @@ func (o SysctlArrayOutput) ToSysctlArrayOutputWithContext(ctx context.Context) S return o } +func (o SysctlArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Sysctl] { + return pulumix.Output[[]Sysctl]{ + OutputState: o.OutputState, + } +} + func (o SysctlArrayOutput) Index(i pulumi.IntInput) SysctlOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Sysctl { return vs[0].([]Sysctl)[vs[1].(int)] @@ -63405,6 +71434,12 @@ func (i SysctlPatchArgs) ToSysctlPatchOutputWithContext(ctx context.Context) Sys return pulumi.ToOutputWithContext(ctx, i).(SysctlPatchOutput) } +func (i SysctlPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SysctlPatch] { + return pulumix.Output[SysctlPatch]{ + OutputState: i.ToSysctlPatchOutputWithContext(ctx).OutputState, + } +} + // SysctlPatchArrayInput is an input type that accepts SysctlPatchArray and SysctlPatchArrayOutput values. // You can construct a concrete instance of `SysctlPatchArrayInput` via: // @@ -63430,6 +71465,12 @@ func (i SysctlPatchArray) ToSysctlPatchArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(SysctlPatchArrayOutput) } +func (i SysctlPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SysctlPatch] { + return pulumix.Output[[]SysctlPatch]{ + OutputState: i.ToSysctlPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Sysctl defines a kernel parameter to be set type SysctlPatchOutput struct{ *pulumi.OutputState } @@ -63445,6 +71486,12 @@ func (o SysctlPatchOutput) ToSysctlPatchOutputWithContext(ctx context.Context) S return o } +func (o SysctlPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SysctlPatch] { + return pulumix.Output[SysctlPatch]{ + OutputState: o.OutputState, + } +} + // Name of a property to set func (o SysctlPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v SysctlPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -63469,6 +71516,12 @@ func (o SysctlPatchArrayOutput) ToSysctlPatchArrayOutputWithContext(ctx context. return o } +func (o SysctlPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SysctlPatch] { + return pulumix.Output[[]SysctlPatch]{ + OutputState: o.OutputState, + } +} + func (o SysctlPatchArrayOutput) Index(i pulumi.IntInput) SysctlPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SysctlPatch { return vs[0].([]SysctlPatch)[vs[1].(int)] @@ -63514,6 +71567,12 @@ func (i TCPSocketActionArgs) ToTCPSocketActionOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(TCPSocketActionOutput) } +func (i TCPSocketActionArgs) ToOutput(ctx context.Context) pulumix.Output[TCPSocketAction] { + return pulumix.Output[TCPSocketAction]{ + OutputState: i.ToTCPSocketActionOutputWithContext(ctx).OutputState, + } +} + func (i TCPSocketActionArgs) ToTCPSocketActionPtrOutput() TCPSocketActionPtrOutput { return i.ToTCPSocketActionPtrOutputWithContext(context.Background()) } @@ -63555,6 +71614,12 @@ func (i *tcpsocketActionPtrType) ToTCPSocketActionPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(TCPSocketActionPtrOutput) } +func (i *tcpsocketActionPtrType) ToOutput(ctx context.Context) pulumix.Output[*TCPSocketAction] { + return pulumix.Output[*TCPSocketAction]{ + OutputState: i.ToTCPSocketActionPtrOutputWithContext(ctx).OutputState, + } +} + // TCPSocketAction describes an action based on opening a socket type TCPSocketActionOutput struct{ *pulumi.OutputState } @@ -63580,6 +71645,12 @@ func (o TCPSocketActionOutput) ToTCPSocketActionPtrOutputWithContext(ctx context }).(TCPSocketActionPtrOutput) } +func (o TCPSocketActionOutput) ToOutput(ctx context.Context) pulumix.Output[TCPSocketAction] { + return pulumix.Output[TCPSocketAction]{ + OutputState: o.OutputState, + } +} + // Optional: Host name to connect to, defaults to the pod IP. func (o TCPSocketActionOutput) Host() pulumi.StringPtrOutput { return o.ApplyT(func(v TCPSocketAction) *string { return v.Host }).(pulumi.StringPtrOutput) @@ -63604,6 +71675,12 @@ func (o TCPSocketActionPtrOutput) ToTCPSocketActionPtrOutputWithContext(ctx cont return o } +func (o TCPSocketActionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TCPSocketAction] { + return pulumix.Output[*TCPSocketAction]{ + OutputState: o.OutputState, + } +} + func (o TCPSocketActionPtrOutput) Elem() TCPSocketActionOutput { return o.ApplyT(func(v *TCPSocketAction) TCPSocketAction { if v != nil { @@ -63673,6 +71750,12 @@ func (i TCPSocketActionPatchArgs) ToTCPSocketActionPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TCPSocketActionPatchOutput) } +func (i TCPSocketActionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TCPSocketActionPatch] { + return pulumix.Output[TCPSocketActionPatch]{ + OutputState: i.ToTCPSocketActionPatchOutputWithContext(ctx).OutputState, + } +} + func (i TCPSocketActionPatchArgs) ToTCPSocketActionPatchPtrOutput() TCPSocketActionPatchPtrOutput { return i.ToTCPSocketActionPatchPtrOutputWithContext(context.Background()) } @@ -63714,6 +71797,12 @@ func (i *tcpsocketActionPatchPtrType) ToTCPSocketActionPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(TCPSocketActionPatchPtrOutput) } +func (i *tcpsocketActionPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TCPSocketActionPatch] { + return pulumix.Output[*TCPSocketActionPatch]{ + OutputState: i.ToTCPSocketActionPatchPtrOutputWithContext(ctx).OutputState, + } +} + // TCPSocketAction describes an action based on opening a socket type TCPSocketActionPatchOutput struct{ *pulumi.OutputState } @@ -63739,6 +71828,12 @@ func (o TCPSocketActionPatchOutput) ToTCPSocketActionPatchPtrOutputWithContext(c }).(TCPSocketActionPatchPtrOutput) } +func (o TCPSocketActionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TCPSocketActionPatch] { + return pulumix.Output[TCPSocketActionPatch]{ + OutputState: o.OutputState, + } +} + // Optional: Host name to connect to, defaults to the pod IP. func (o TCPSocketActionPatchOutput) Host() pulumi.StringPtrOutput { return o.ApplyT(func(v TCPSocketActionPatch) *string { return v.Host }).(pulumi.StringPtrOutput) @@ -63763,6 +71858,12 @@ func (o TCPSocketActionPatchPtrOutput) ToTCPSocketActionPatchPtrOutputWithContex return o } +func (o TCPSocketActionPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TCPSocketActionPatch] { + return pulumix.Output[*TCPSocketActionPatch]{ + OutputState: o.OutputState, + } +} + func (o TCPSocketActionPatchPtrOutput) Elem() TCPSocketActionPatchOutput { return o.ApplyT(func(v *TCPSocketActionPatch) TCPSocketActionPatch { if v != nil { @@ -63840,6 +71941,12 @@ func (i TaintArgs) ToTaintOutputWithContext(ctx context.Context) TaintOutput { return pulumi.ToOutputWithContext(ctx, i).(TaintOutput) } +func (i TaintArgs) ToOutput(ctx context.Context) pulumix.Output[Taint] { + return pulumix.Output[Taint]{ + OutputState: i.ToTaintOutputWithContext(ctx).OutputState, + } +} + // TaintArrayInput is an input type that accepts TaintArray and TaintArrayOutput values. // You can construct a concrete instance of `TaintArrayInput` via: // @@ -63865,6 +71972,12 @@ func (i TaintArray) ToTaintArrayOutputWithContext(ctx context.Context) TaintArra return pulumi.ToOutputWithContext(ctx, i).(TaintArrayOutput) } +func (i TaintArray) ToOutput(ctx context.Context) pulumix.Output[[]Taint] { + return pulumix.Output[[]Taint]{ + OutputState: i.ToTaintArrayOutputWithContext(ctx).OutputState, + } +} + // The node this Taint is attached to has the "effect" on any pod that does not tolerate the Taint. type TaintOutput struct{ *pulumi.OutputState } @@ -63880,6 +71993,12 @@ func (o TaintOutput) ToTaintOutputWithContext(ctx context.Context) TaintOutput { return o } +func (o TaintOutput) ToOutput(ctx context.Context) pulumix.Output[Taint] { + return pulumix.Output[Taint]{ + OutputState: o.OutputState, + } +} + // Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. func (o TaintOutput) Effect() pulumi.StringOutput { return o.ApplyT(func(v Taint) string { return v.Effect }).(pulumi.StringOutput) @@ -63914,6 +72033,12 @@ func (o TaintArrayOutput) ToTaintArrayOutputWithContext(ctx context.Context) Tai return o } +func (o TaintArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Taint] { + return pulumix.Output[[]Taint]{ + OutputState: o.OutputState, + } +} + func (o TaintArrayOutput) Index(i pulumi.IntInput) TaintOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Taint { return vs[0].([]Taint)[vs[1].(int)] @@ -63967,6 +72092,12 @@ func (i TaintPatchArgs) ToTaintPatchOutputWithContext(ctx context.Context) Taint return pulumi.ToOutputWithContext(ctx, i).(TaintPatchOutput) } +func (i TaintPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TaintPatch] { + return pulumix.Output[TaintPatch]{ + OutputState: i.ToTaintPatchOutputWithContext(ctx).OutputState, + } +} + // TaintPatchArrayInput is an input type that accepts TaintPatchArray and TaintPatchArrayOutput values. // You can construct a concrete instance of `TaintPatchArrayInput` via: // @@ -63992,6 +72123,12 @@ func (i TaintPatchArray) ToTaintPatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(TaintPatchArrayOutput) } +func (i TaintPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TaintPatch] { + return pulumix.Output[[]TaintPatch]{ + OutputState: i.ToTaintPatchArrayOutputWithContext(ctx).OutputState, + } +} + // The node this Taint is attached to has the "effect" on any pod that does not tolerate the Taint. type TaintPatchOutput struct{ *pulumi.OutputState } @@ -64007,6 +72144,12 @@ func (o TaintPatchOutput) ToTaintPatchOutputWithContext(ctx context.Context) Tai return o } +func (o TaintPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TaintPatch] { + return pulumix.Output[TaintPatch]{ + OutputState: o.OutputState, + } +} + // Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. func (o TaintPatchOutput) Effect() pulumi.StringPtrOutput { return o.ApplyT(func(v TaintPatch) *string { return v.Effect }).(pulumi.StringPtrOutput) @@ -64041,6 +72184,12 @@ func (o TaintPatchArrayOutput) ToTaintPatchArrayOutputWithContext(ctx context.Co return o } +func (o TaintPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TaintPatch] { + return pulumix.Output[[]TaintPatch]{ + OutputState: o.OutputState, + } +} + func (o TaintPatchArrayOutput) Index(i pulumi.IntInput) TaintPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TaintPatch { return vs[0].([]TaintPatch)[vs[1].(int)] @@ -64098,6 +72247,12 @@ func (i TolerationArgs) ToTolerationOutputWithContext(ctx context.Context) Toler return pulumi.ToOutputWithContext(ctx, i).(TolerationOutput) } +func (i TolerationArgs) ToOutput(ctx context.Context) pulumix.Output[Toleration] { + return pulumix.Output[Toleration]{ + OutputState: i.ToTolerationOutputWithContext(ctx).OutputState, + } +} + // TolerationArrayInput is an input type that accepts TolerationArray and TolerationArrayOutput values. // You can construct a concrete instance of `TolerationArrayInput` via: // @@ -64123,6 +72278,12 @@ func (i TolerationArray) ToTolerationArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(TolerationArrayOutput) } +func (i TolerationArray) ToOutput(ctx context.Context) pulumix.Output[[]Toleration] { + return pulumix.Output[[]Toleration]{ + OutputState: i.ToTolerationArrayOutputWithContext(ctx).OutputState, + } +} + // The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator . type TolerationOutput struct{ *pulumi.OutputState } @@ -64138,6 +72299,12 @@ func (o TolerationOutput) ToTolerationOutputWithContext(ctx context.Context) Tol return o } +func (o TolerationOutput) ToOutput(ctx context.Context) pulumix.Output[Toleration] { + return pulumix.Output[Toleration]{ + OutputState: o.OutputState, + } +} + // Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. func (o TolerationOutput) Effect() pulumi.StringPtrOutput { return o.ApplyT(func(v Toleration) *string { return v.Effect }).(pulumi.StringPtrOutput) @@ -64177,6 +72344,12 @@ func (o TolerationArrayOutput) ToTolerationArrayOutputWithContext(ctx context.Co return o } +func (o TolerationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Toleration] { + return pulumix.Output[[]Toleration]{ + OutputState: o.OutputState, + } +} + func (o TolerationArrayOutput) Index(i pulumi.IntInput) TolerationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Toleration { return vs[0].([]Toleration)[vs[1].(int)] @@ -64234,6 +72407,12 @@ func (i TolerationPatchArgs) ToTolerationPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(TolerationPatchOutput) } +func (i TolerationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TolerationPatch] { + return pulumix.Output[TolerationPatch]{ + OutputState: i.ToTolerationPatchOutputWithContext(ctx).OutputState, + } +} + // TolerationPatchArrayInput is an input type that accepts TolerationPatchArray and TolerationPatchArrayOutput values. // You can construct a concrete instance of `TolerationPatchArrayInput` via: // @@ -64259,6 +72438,12 @@ func (i TolerationPatchArray) ToTolerationPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(TolerationPatchArrayOutput) } +func (i TolerationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TolerationPatch] { + return pulumix.Output[[]TolerationPatch]{ + OutputState: i.ToTolerationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator . type TolerationPatchOutput struct{ *pulumi.OutputState } @@ -64274,6 +72459,12 @@ func (o TolerationPatchOutput) ToTolerationPatchOutputWithContext(ctx context.Co return o } +func (o TolerationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TolerationPatch] { + return pulumix.Output[TolerationPatch]{ + OutputState: o.OutputState, + } +} + // Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. func (o TolerationPatchOutput) Effect() pulumi.StringPtrOutput { return o.ApplyT(func(v TolerationPatch) *string { return v.Effect }).(pulumi.StringPtrOutput) @@ -64313,6 +72504,12 @@ func (o TolerationPatchArrayOutput) ToTolerationPatchArrayOutputWithContext(ctx return o } +func (o TolerationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TolerationPatch] { + return pulumix.Output[[]TolerationPatch]{ + OutputState: o.OutputState, + } +} + func (o TolerationPatchArrayOutput) Index(i pulumi.IntInput) TolerationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TolerationPatch { return vs[0].([]TolerationPatch)[vs[1].(int)] @@ -64358,6 +72555,12 @@ func (i TopologySelectorLabelRequirementArgs) ToTopologySelectorLabelRequirement return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorLabelRequirementOutput) } +func (i TopologySelectorLabelRequirementArgs) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorLabelRequirement] { + return pulumix.Output[TopologySelectorLabelRequirement]{ + OutputState: i.ToTopologySelectorLabelRequirementOutputWithContext(ctx).OutputState, + } +} + // TopologySelectorLabelRequirementArrayInput is an input type that accepts TopologySelectorLabelRequirementArray and TopologySelectorLabelRequirementArrayOutput values. // You can construct a concrete instance of `TopologySelectorLabelRequirementArrayInput` via: // @@ -64383,6 +72586,12 @@ func (i TopologySelectorLabelRequirementArray) ToTopologySelectorLabelRequiremen return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorLabelRequirementArrayOutput) } +func (i TopologySelectorLabelRequirementArray) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorLabelRequirement] { + return pulumix.Output[[]TopologySelectorLabelRequirement]{ + OutputState: i.ToTopologySelectorLabelRequirementArrayOutputWithContext(ctx).OutputState, + } +} + // A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future. type TopologySelectorLabelRequirementOutput struct{ *pulumi.OutputState } @@ -64398,6 +72607,12 @@ func (o TopologySelectorLabelRequirementOutput) ToTopologySelectorLabelRequireme return o } +func (o TopologySelectorLabelRequirementOutput) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorLabelRequirement] { + return pulumix.Output[TopologySelectorLabelRequirement]{ + OutputState: o.OutputState, + } +} + // The label key that the selector applies to. func (o TopologySelectorLabelRequirementOutput) Key() pulumi.StringOutput { return o.ApplyT(func(v TopologySelectorLabelRequirement) string { return v.Key }).(pulumi.StringOutput) @@ -64422,6 +72637,12 @@ func (o TopologySelectorLabelRequirementArrayOutput) ToTopologySelectorLabelRequ return o } +func (o TopologySelectorLabelRequirementArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorLabelRequirement] { + return pulumix.Output[[]TopologySelectorLabelRequirement]{ + OutputState: o.OutputState, + } +} + func (o TopologySelectorLabelRequirementArrayOutput) Index(i pulumi.IntInput) TopologySelectorLabelRequirementOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TopologySelectorLabelRequirement { return vs[0].([]TopologySelectorLabelRequirement)[vs[1].(int)] @@ -64467,6 +72688,12 @@ func (i TopologySelectorLabelRequirementPatchArgs) ToTopologySelectorLabelRequir return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorLabelRequirementPatchOutput) } +func (i TopologySelectorLabelRequirementPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorLabelRequirementPatch] { + return pulumix.Output[TopologySelectorLabelRequirementPatch]{ + OutputState: i.ToTopologySelectorLabelRequirementPatchOutputWithContext(ctx).OutputState, + } +} + // TopologySelectorLabelRequirementPatchArrayInput is an input type that accepts TopologySelectorLabelRequirementPatchArray and TopologySelectorLabelRequirementPatchArrayOutput values. // You can construct a concrete instance of `TopologySelectorLabelRequirementPatchArrayInput` via: // @@ -64492,6 +72719,12 @@ func (i TopologySelectorLabelRequirementPatchArray) ToTopologySelectorLabelRequi return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorLabelRequirementPatchArrayOutput) } +func (i TopologySelectorLabelRequirementPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorLabelRequirementPatch] { + return pulumix.Output[[]TopologySelectorLabelRequirementPatch]{ + OutputState: i.ToTopologySelectorLabelRequirementPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future. type TopologySelectorLabelRequirementPatchOutput struct{ *pulumi.OutputState } @@ -64507,6 +72740,12 @@ func (o TopologySelectorLabelRequirementPatchOutput) ToTopologySelectorLabelRequ return o } +func (o TopologySelectorLabelRequirementPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorLabelRequirementPatch] { + return pulumix.Output[TopologySelectorLabelRequirementPatch]{ + OutputState: o.OutputState, + } +} + // The label key that the selector applies to. func (o TopologySelectorLabelRequirementPatchOutput) Key() pulumi.StringPtrOutput { return o.ApplyT(func(v TopologySelectorLabelRequirementPatch) *string { return v.Key }).(pulumi.StringPtrOutput) @@ -64531,6 +72770,12 @@ func (o TopologySelectorLabelRequirementPatchArrayOutput) ToTopologySelectorLabe return o } +func (o TopologySelectorLabelRequirementPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorLabelRequirementPatch] { + return pulumix.Output[[]TopologySelectorLabelRequirementPatch]{ + OutputState: o.OutputState, + } +} + func (o TopologySelectorLabelRequirementPatchArrayOutput) Index(i pulumi.IntInput) TopologySelectorLabelRequirementPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TopologySelectorLabelRequirementPatch { return vs[0].([]TopologySelectorLabelRequirementPatch)[vs[1].(int)] @@ -64572,6 +72817,12 @@ func (i TopologySelectorTermArgs) ToTopologySelectorTermOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorTermOutput) } +func (i TopologySelectorTermArgs) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorTerm] { + return pulumix.Output[TopologySelectorTerm]{ + OutputState: i.ToTopologySelectorTermOutputWithContext(ctx).OutputState, + } +} + // TopologySelectorTermArrayInput is an input type that accepts TopologySelectorTermArray and TopologySelectorTermArrayOutput values. // You can construct a concrete instance of `TopologySelectorTermArrayInput` via: // @@ -64597,6 +72848,12 @@ func (i TopologySelectorTermArray) ToTopologySelectorTermArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorTermArrayOutput) } +func (i TopologySelectorTermArray) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorTerm] { + return pulumix.Output[[]TopologySelectorTerm]{ + OutputState: i.ToTopologySelectorTermArrayOutputWithContext(ctx).OutputState, + } +} + // A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future. type TopologySelectorTermOutput struct{ *pulumi.OutputState } @@ -64612,6 +72869,12 @@ func (o TopologySelectorTermOutput) ToTopologySelectorTermOutputWithContext(ctx return o } +func (o TopologySelectorTermOutput) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorTerm] { + return pulumix.Output[TopologySelectorTerm]{ + OutputState: o.OutputState, + } +} + // A list of topology selector requirements by labels. func (o TopologySelectorTermOutput) MatchLabelExpressions() TopologySelectorLabelRequirementArrayOutput { return o.ApplyT(func(v TopologySelectorTerm) []TopologySelectorLabelRequirement { return v.MatchLabelExpressions }).(TopologySelectorLabelRequirementArrayOutput) @@ -64631,6 +72894,12 @@ func (o TopologySelectorTermArrayOutput) ToTopologySelectorTermArrayOutputWithCo return o } +func (o TopologySelectorTermArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorTerm] { + return pulumix.Output[[]TopologySelectorTerm]{ + OutputState: o.OutputState, + } +} + func (o TopologySelectorTermArrayOutput) Index(i pulumi.IntInput) TopologySelectorTermOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TopologySelectorTerm { return vs[0].([]TopologySelectorTerm)[vs[1].(int)] @@ -64672,6 +72941,12 @@ func (i TopologySelectorTermPatchArgs) ToTopologySelectorTermPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorTermPatchOutput) } +func (i TopologySelectorTermPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorTermPatch] { + return pulumix.Output[TopologySelectorTermPatch]{ + OutputState: i.ToTopologySelectorTermPatchOutputWithContext(ctx).OutputState, + } +} + // TopologySelectorTermPatchArrayInput is an input type that accepts TopologySelectorTermPatchArray and TopologySelectorTermPatchArrayOutput values. // You can construct a concrete instance of `TopologySelectorTermPatchArrayInput` via: // @@ -64697,6 +72972,12 @@ func (i TopologySelectorTermPatchArray) ToTopologySelectorTermPatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(TopologySelectorTermPatchArrayOutput) } +func (i TopologySelectorTermPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorTermPatch] { + return pulumix.Output[[]TopologySelectorTermPatch]{ + OutputState: i.ToTopologySelectorTermPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future. type TopologySelectorTermPatchOutput struct{ *pulumi.OutputState } @@ -64712,6 +72993,12 @@ func (o TopologySelectorTermPatchOutput) ToTopologySelectorTermPatchOutputWithCo return o } +func (o TopologySelectorTermPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TopologySelectorTermPatch] { + return pulumix.Output[TopologySelectorTermPatch]{ + OutputState: o.OutputState, + } +} + // A list of topology selector requirements by labels. func (o TopologySelectorTermPatchOutput) MatchLabelExpressions() TopologySelectorLabelRequirementPatchArrayOutput { return o.ApplyT(func(v TopologySelectorTermPatch) []TopologySelectorLabelRequirementPatch { @@ -64733,6 +73020,12 @@ func (o TopologySelectorTermPatchArrayOutput) ToTopologySelectorTermPatchArrayOu return o } +func (o TopologySelectorTermPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TopologySelectorTermPatch] { + return pulumix.Output[[]TopologySelectorTermPatch]{ + OutputState: o.OutputState, + } +} + func (o TopologySelectorTermPatchArrayOutput) Index(i pulumi.IntInput) TopologySelectorTermPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TopologySelectorTermPatch { return vs[0].([]TopologySelectorTermPatch)[vs[1].(int)] @@ -64828,6 +73121,12 @@ func (i TopologySpreadConstraintArgs) ToTopologySpreadConstraintOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(TopologySpreadConstraintOutput) } +func (i TopologySpreadConstraintArgs) ToOutput(ctx context.Context) pulumix.Output[TopologySpreadConstraint] { + return pulumix.Output[TopologySpreadConstraint]{ + OutputState: i.ToTopologySpreadConstraintOutputWithContext(ctx).OutputState, + } +} + // TopologySpreadConstraintArrayInput is an input type that accepts TopologySpreadConstraintArray and TopologySpreadConstraintArrayOutput values. // You can construct a concrete instance of `TopologySpreadConstraintArrayInput` via: // @@ -64853,6 +73152,12 @@ func (i TopologySpreadConstraintArray) ToTopologySpreadConstraintArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(TopologySpreadConstraintArrayOutput) } +func (i TopologySpreadConstraintArray) ToOutput(ctx context.Context) pulumix.Output[[]TopologySpreadConstraint] { + return pulumix.Output[[]TopologySpreadConstraint]{ + OutputState: i.ToTopologySpreadConstraintArrayOutputWithContext(ctx).OutputState, + } +} + // TopologySpreadConstraint specifies how to spread matching pods among the given topology. type TopologySpreadConstraintOutput struct{ *pulumi.OutputState } @@ -64868,6 +73173,12 @@ func (o TopologySpreadConstraintOutput) ToTopologySpreadConstraintOutputWithCont return o } +func (o TopologySpreadConstraintOutput) ToOutput(ctx context.Context) pulumix.Output[TopologySpreadConstraint] { + return pulumix.Output[TopologySpreadConstraint]{ + OutputState: o.OutputState, + } +} + // LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain. func (o TopologySpreadConstraintOutput) LabelSelector() metav1.LabelSelectorPtrOutput { return o.ApplyT(func(v TopologySpreadConstraint) *metav1.LabelSelector { return v.LabelSelector }).(metav1.LabelSelectorPtrOutput) @@ -64937,6 +73248,12 @@ func (o TopologySpreadConstraintArrayOutput) ToTopologySpreadConstraintArrayOutp return o } +func (o TopologySpreadConstraintArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TopologySpreadConstraint] { + return pulumix.Output[[]TopologySpreadConstraint]{ + OutputState: o.OutputState, + } +} + func (o TopologySpreadConstraintArrayOutput) Index(i pulumi.IntInput) TopologySpreadConstraintOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TopologySpreadConstraint { return vs[0].([]TopologySpreadConstraint)[vs[1].(int)] @@ -65032,6 +73349,12 @@ func (i TopologySpreadConstraintPatchArgs) ToTopologySpreadConstraintPatchOutput return pulumi.ToOutputWithContext(ctx, i).(TopologySpreadConstraintPatchOutput) } +func (i TopologySpreadConstraintPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TopologySpreadConstraintPatch] { + return pulumix.Output[TopologySpreadConstraintPatch]{ + OutputState: i.ToTopologySpreadConstraintPatchOutputWithContext(ctx).OutputState, + } +} + // TopologySpreadConstraintPatchArrayInput is an input type that accepts TopologySpreadConstraintPatchArray and TopologySpreadConstraintPatchArrayOutput values. // You can construct a concrete instance of `TopologySpreadConstraintPatchArrayInput` via: // @@ -65057,6 +73380,12 @@ func (i TopologySpreadConstraintPatchArray) ToTopologySpreadConstraintPatchArray return pulumi.ToOutputWithContext(ctx, i).(TopologySpreadConstraintPatchArrayOutput) } +func (i TopologySpreadConstraintPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TopologySpreadConstraintPatch] { + return pulumix.Output[[]TopologySpreadConstraintPatch]{ + OutputState: i.ToTopologySpreadConstraintPatchArrayOutputWithContext(ctx).OutputState, + } +} + // TopologySpreadConstraint specifies how to spread matching pods among the given topology. type TopologySpreadConstraintPatchOutput struct{ *pulumi.OutputState } @@ -65072,6 +73401,12 @@ func (o TopologySpreadConstraintPatchOutput) ToTopologySpreadConstraintPatchOutp return o } +func (o TopologySpreadConstraintPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TopologySpreadConstraintPatch] { + return pulumix.Output[TopologySpreadConstraintPatch]{ + OutputState: o.OutputState, + } +} + // LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain. func (o TopologySpreadConstraintPatchOutput) LabelSelector() metav1.LabelSelectorPatchPtrOutput { return o.ApplyT(func(v TopologySpreadConstraintPatch) *metav1.LabelSelectorPatch { return v.LabelSelector }).(metav1.LabelSelectorPatchPtrOutput) @@ -65141,6 +73476,12 @@ func (o TopologySpreadConstraintPatchArrayOutput) ToTopologySpreadConstraintPatc return o } +func (o TopologySpreadConstraintPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TopologySpreadConstraintPatch] { + return pulumix.Output[[]TopologySpreadConstraintPatch]{ + OutputState: o.OutputState, + } +} + func (o TopologySpreadConstraintPatchArrayOutput) Index(i pulumi.IntInput) TopologySpreadConstraintPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TopologySpreadConstraintPatch { return vs[0].([]TopologySpreadConstraintPatch)[vs[1].(int)] @@ -65190,6 +73531,12 @@ func (i TypedLocalObjectReferenceArgs) ToTypedLocalObjectReferenceOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(TypedLocalObjectReferenceOutput) } +func (i TypedLocalObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[TypedLocalObjectReference] { + return pulumix.Output[TypedLocalObjectReference]{ + OutputState: i.ToTypedLocalObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i TypedLocalObjectReferenceArgs) ToTypedLocalObjectReferencePtrOutput() TypedLocalObjectReferencePtrOutput { return i.ToTypedLocalObjectReferencePtrOutputWithContext(context.Background()) } @@ -65231,6 +73578,12 @@ func (i *typedLocalObjectReferencePtrType) ToTypedLocalObjectReferencePtrOutputW return pulumi.ToOutputWithContext(ctx, i).(TypedLocalObjectReferencePtrOutput) } +func (i *typedLocalObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*TypedLocalObjectReference] { + return pulumix.Output[*TypedLocalObjectReference]{ + OutputState: i.ToTypedLocalObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + // TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace. type TypedLocalObjectReferenceOutput struct{ *pulumi.OutputState } @@ -65256,6 +73609,12 @@ func (o TypedLocalObjectReferenceOutput) ToTypedLocalObjectReferencePtrOutputWit }).(TypedLocalObjectReferencePtrOutput) } +func (o TypedLocalObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[TypedLocalObjectReference] { + return pulumix.Output[TypedLocalObjectReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. func (o TypedLocalObjectReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v TypedLocalObjectReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -65285,6 +73644,12 @@ func (o TypedLocalObjectReferencePtrOutput) ToTypedLocalObjectReferencePtrOutput return o } +func (o TypedLocalObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypedLocalObjectReference] { + return pulumix.Output[*TypedLocalObjectReference]{ + OutputState: o.OutputState, + } +} + func (o TypedLocalObjectReferencePtrOutput) Elem() TypedLocalObjectReferenceOutput { return o.ApplyT(func(v *TypedLocalObjectReference) TypedLocalObjectReference { if v != nil { @@ -65368,6 +73733,12 @@ func (i TypedLocalObjectReferencePatchArgs) ToTypedLocalObjectReferencePatchOutp return pulumi.ToOutputWithContext(ctx, i).(TypedLocalObjectReferencePatchOutput) } +func (i TypedLocalObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[TypedLocalObjectReferencePatch] { + return pulumix.Output[TypedLocalObjectReferencePatch]{ + OutputState: i.ToTypedLocalObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i TypedLocalObjectReferencePatchArgs) ToTypedLocalObjectReferencePatchPtrOutput() TypedLocalObjectReferencePatchPtrOutput { return i.ToTypedLocalObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -65409,6 +73780,12 @@ func (i *typedLocalObjectReferencePatchPtrType) ToTypedLocalObjectReferencePatch return pulumi.ToOutputWithContext(ctx, i).(TypedLocalObjectReferencePatchPtrOutput) } +func (i *typedLocalObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TypedLocalObjectReferencePatch] { + return pulumix.Output[*TypedLocalObjectReferencePatch]{ + OutputState: i.ToTypedLocalObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace. type TypedLocalObjectReferencePatchOutput struct{ *pulumi.OutputState } @@ -65434,6 +73811,12 @@ func (o TypedLocalObjectReferencePatchOutput) ToTypedLocalObjectReferencePatchPt }).(TypedLocalObjectReferencePatchPtrOutput) } +func (o TypedLocalObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[TypedLocalObjectReferencePatch] { + return pulumix.Output[TypedLocalObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. func (o TypedLocalObjectReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v TypedLocalObjectReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -65463,6 +73846,12 @@ func (o TypedLocalObjectReferencePatchPtrOutput) ToTypedLocalObjectReferencePatc return o } +func (o TypedLocalObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypedLocalObjectReferencePatch] { + return pulumix.Output[*TypedLocalObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o TypedLocalObjectReferencePatchPtrOutput) Elem() TypedLocalObjectReferencePatchOutput { return o.ApplyT(func(v *TypedLocalObjectReferencePatch) TypedLocalObjectReferencePatch { if v != nil { @@ -65548,6 +73937,12 @@ func (i TypedObjectReferenceArgs) ToTypedObjectReferenceOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TypedObjectReferenceOutput) } +func (i TypedObjectReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[TypedObjectReference] { + return pulumix.Output[TypedObjectReference]{ + OutputState: i.ToTypedObjectReferenceOutputWithContext(ctx).OutputState, + } +} + func (i TypedObjectReferenceArgs) ToTypedObjectReferencePtrOutput() TypedObjectReferencePtrOutput { return i.ToTypedObjectReferencePtrOutputWithContext(context.Background()) } @@ -65589,6 +73984,12 @@ func (i *typedObjectReferencePtrType) ToTypedObjectReferencePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(TypedObjectReferencePtrOutput) } +func (i *typedObjectReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*TypedObjectReference] { + return pulumix.Output[*TypedObjectReference]{ + OutputState: i.ToTypedObjectReferencePtrOutputWithContext(ctx).OutputState, + } +} + type TypedObjectReferenceOutput struct{ *pulumi.OutputState } func (TypedObjectReferenceOutput) ElementType() reflect.Type { @@ -65613,6 +74014,12 @@ func (o TypedObjectReferenceOutput) ToTypedObjectReferencePtrOutputWithContext(c }).(TypedObjectReferencePtrOutput) } +func (o TypedObjectReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[TypedObjectReference] { + return pulumix.Output[TypedObjectReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. func (o TypedObjectReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v TypedObjectReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -65647,6 +74054,12 @@ func (o TypedObjectReferencePtrOutput) ToTypedObjectReferencePtrOutputWithContex return o } +func (o TypedObjectReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypedObjectReference] { + return pulumix.Output[*TypedObjectReference]{ + OutputState: o.OutputState, + } +} + func (o TypedObjectReferencePtrOutput) Elem() TypedObjectReferenceOutput { return o.ApplyT(func(v *TypedObjectReference) TypedObjectReference { if v != nil { @@ -65742,6 +74155,12 @@ func (i TypedObjectReferencePatchArgs) ToTypedObjectReferencePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(TypedObjectReferencePatchOutput) } +func (i TypedObjectReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[TypedObjectReferencePatch] { + return pulumix.Output[TypedObjectReferencePatch]{ + OutputState: i.ToTypedObjectReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i TypedObjectReferencePatchArgs) ToTypedObjectReferencePatchPtrOutput() TypedObjectReferencePatchPtrOutput { return i.ToTypedObjectReferencePatchPtrOutputWithContext(context.Background()) } @@ -65783,6 +74202,12 @@ func (i *typedObjectReferencePatchPtrType) ToTypedObjectReferencePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(TypedObjectReferencePatchPtrOutput) } +func (i *typedObjectReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*TypedObjectReferencePatch] { + return pulumix.Output[*TypedObjectReferencePatch]{ + OutputState: i.ToTypedObjectReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + type TypedObjectReferencePatchOutput struct{ *pulumi.OutputState } func (TypedObjectReferencePatchOutput) ElementType() reflect.Type { @@ -65807,6 +74232,12 @@ func (o TypedObjectReferencePatchOutput) ToTypedObjectReferencePatchPtrOutputWit }).(TypedObjectReferencePatchPtrOutput) } +func (o TypedObjectReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[TypedObjectReferencePatch] { + return pulumix.Output[TypedObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. func (o TypedObjectReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v TypedObjectReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -65841,6 +74272,12 @@ func (o TypedObjectReferencePatchPtrOutput) ToTypedObjectReferencePatchPtrOutput return o } +func (o TypedObjectReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*TypedObjectReferencePatch] { + return pulumix.Output[*TypedObjectReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o TypedObjectReferencePatchPtrOutput) Elem() TypedObjectReferencePatchOutput { return o.ApplyT(func(v *TypedObjectReferencePatch) TypedObjectReferencePatch { if v != nil { @@ -66068,6 +74505,12 @@ func (i VolumeArgs) ToVolumeOutputWithContext(ctx context.Context) VolumeOutput return pulumi.ToOutputWithContext(ctx, i).(VolumeOutput) } +func (i VolumeArgs) ToOutput(ctx context.Context) pulumix.Output[Volume] { + return pulumix.Output[Volume]{ + OutputState: i.ToVolumeOutputWithContext(ctx).OutputState, + } +} + // VolumeArrayInput is an input type that accepts VolumeArray and VolumeArrayOutput values. // You can construct a concrete instance of `VolumeArrayInput` via: // @@ -66093,6 +74536,12 @@ func (i VolumeArray) ToVolumeArrayOutputWithContext(ctx context.Context) VolumeA return pulumi.ToOutputWithContext(ctx, i).(VolumeArrayOutput) } +func (i VolumeArray) ToOutput(ctx context.Context) pulumix.Output[[]Volume] { + return pulumix.Output[[]Volume]{ + OutputState: i.ToVolumeArrayOutputWithContext(ctx).OutputState, + } +} + // Volume represents a named volume in a pod that may be accessed by any container in the pod. type VolumeOutput struct{ *pulumi.OutputState } @@ -66108,6 +74557,12 @@ func (o VolumeOutput) ToVolumeOutputWithContext(ctx context.Context) VolumeOutpu return o } +func (o VolumeOutput) ToOutput(ctx context.Context) pulumix.Output[Volume] { + return pulumix.Output[Volume]{ + OutputState: o.OutputState, + } +} + // awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore func (o VolumeOutput) AwsElasticBlockStore() AWSElasticBlockStoreVolumeSourcePtrOutput { return o.ApplyT(func(v Volume) *AWSElasticBlockStoreVolumeSource { return v.AwsElasticBlockStore }).(AWSElasticBlockStoreVolumeSourcePtrOutput) @@ -66288,6 +74743,12 @@ func (o VolumeArrayOutput) ToVolumeArrayOutputWithContext(ctx context.Context) V return o } +func (o VolumeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Volume] { + return pulumix.Output[[]Volume]{ + OutputState: o.OutputState, + } +} + func (o VolumeArrayOutput) Index(i pulumi.IntInput) VolumeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Volume { return vs[0].([]Volume)[vs[1].(int)] @@ -66333,6 +74794,12 @@ func (i VolumeDeviceArgs) ToVolumeDeviceOutputWithContext(ctx context.Context) V return pulumi.ToOutputWithContext(ctx, i).(VolumeDeviceOutput) } +func (i VolumeDeviceArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeDevice] { + return pulumix.Output[VolumeDevice]{ + OutputState: i.ToVolumeDeviceOutputWithContext(ctx).OutputState, + } +} + // VolumeDeviceArrayInput is an input type that accepts VolumeDeviceArray and VolumeDeviceArrayOutput values. // You can construct a concrete instance of `VolumeDeviceArrayInput` via: // @@ -66358,6 +74825,12 @@ func (i VolumeDeviceArray) ToVolumeDeviceArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(VolumeDeviceArrayOutput) } +func (i VolumeDeviceArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeDevice] { + return pulumix.Output[[]VolumeDevice]{ + OutputState: i.ToVolumeDeviceArrayOutputWithContext(ctx).OutputState, + } +} + // volumeDevice describes a mapping of a raw block device within a container. type VolumeDeviceOutput struct{ *pulumi.OutputState } @@ -66373,6 +74846,12 @@ func (o VolumeDeviceOutput) ToVolumeDeviceOutputWithContext(ctx context.Context) return o } +func (o VolumeDeviceOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeDevice] { + return pulumix.Output[VolumeDevice]{ + OutputState: o.OutputState, + } +} + // devicePath is the path inside of the container that the device will be mapped to. func (o VolumeDeviceOutput) DevicePath() pulumi.StringOutput { return o.ApplyT(func(v VolumeDevice) string { return v.DevicePath }).(pulumi.StringOutput) @@ -66397,6 +74876,12 @@ func (o VolumeDeviceArrayOutput) ToVolumeDeviceArrayOutputWithContext(ctx contex return o } +func (o VolumeDeviceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeDevice] { + return pulumix.Output[[]VolumeDevice]{ + OutputState: o.OutputState, + } +} + func (o VolumeDeviceArrayOutput) Index(i pulumi.IntInput) VolumeDeviceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeDevice { return vs[0].([]VolumeDevice)[vs[1].(int)] @@ -66442,6 +74927,12 @@ func (i VolumeDevicePatchArgs) ToVolumeDevicePatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(VolumeDevicePatchOutput) } +func (i VolumeDevicePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeDevicePatch] { + return pulumix.Output[VolumeDevicePatch]{ + OutputState: i.ToVolumeDevicePatchOutputWithContext(ctx).OutputState, + } +} + // VolumeDevicePatchArrayInput is an input type that accepts VolumeDevicePatchArray and VolumeDevicePatchArrayOutput values. // You can construct a concrete instance of `VolumeDevicePatchArrayInput` via: // @@ -66467,6 +74958,12 @@ func (i VolumeDevicePatchArray) ToVolumeDevicePatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeDevicePatchArrayOutput) } +func (i VolumeDevicePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeDevicePatch] { + return pulumix.Output[[]VolumeDevicePatch]{ + OutputState: i.ToVolumeDevicePatchArrayOutputWithContext(ctx).OutputState, + } +} + // volumeDevice describes a mapping of a raw block device within a container. type VolumeDevicePatchOutput struct{ *pulumi.OutputState } @@ -66482,6 +74979,12 @@ func (o VolumeDevicePatchOutput) ToVolumeDevicePatchOutputWithContext(ctx contex return o } +func (o VolumeDevicePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeDevicePatch] { + return pulumix.Output[VolumeDevicePatch]{ + OutputState: o.OutputState, + } +} + // devicePath is the path inside of the container that the device will be mapped to. func (o VolumeDevicePatchOutput) DevicePath() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeDevicePatch) *string { return v.DevicePath }).(pulumi.StringPtrOutput) @@ -66506,6 +75009,12 @@ func (o VolumeDevicePatchArrayOutput) ToVolumeDevicePatchArrayOutputWithContext( return o } +func (o VolumeDevicePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeDevicePatch] { + return pulumix.Output[[]VolumeDevicePatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeDevicePatchArrayOutput) Index(i pulumi.IntInput) VolumeDevicePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeDevicePatch { return vs[0].([]VolumeDevicePatch)[vs[1].(int)] @@ -66567,6 +75076,12 @@ func (i VolumeMountArgs) ToVolumeMountOutputWithContext(ctx context.Context) Vol return pulumi.ToOutputWithContext(ctx, i).(VolumeMountOutput) } +func (i VolumeMountArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeMount] { + return pulumix.Output[VolumeMount]{ + OutputState: i.ToVolumeMountOutputWithContext(ctx).OutputState, + } +} + // VolumeMountArrayInput is an input type that accepts VolumeMountArray and VolumeMountArrayOutput values. // You can construct a concrete instance of `VolumeMountArrayInput` via: // @@ -66592,6 +75107,12 @@ func (i VolumeMountArray) ToVolumeMountArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(VolumeMountArrayOutput) } +func (i VolumeMountArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeMount] { + return pulumix.Output[[]VolumeMount]{ + OutputState: i.ToVolumeMountArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeMount describes a mounting of a Volume within a container. type VolumeMountOutput struct{ *pulumi.OutputState } @@ -66607,6 +75128,12 @@ func (o VolumeMountOutput) ToVolumeMountOutputWithContext(ctx context.Context) V return o } +func (o VolumeMountOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeMount] { + return pulumix.Output[VolumeMount]{ + OutputState: o.OutputState, + } +} + // Path within the container at which the volume should be mounted. Must not contain ':'. func (o VolumeMountOutput) MountPath() pulumi.StringOutput { return o.ApplyT(func(v VolumeMount) string { return v.MountPath }).(pulumi.StringOutput) @@ -66651,6 +75178,12 @@ func (o VolumeMountArrayOutput) ToVolumeMountArrayOutputWithContext(ctx context. return o } +func (o VolumeMountArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeMount] { + return pulumix.Output[[]VolumeMount]{ + OutputState: o.OutputState, + } +} + func (o VolumeMountArrayOutput) Index(i pulumi.IntInput) VolumeMountOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeMount { return vs[0].([]VolumeMount)[vs[1].(int)] @@ -66712,6 +75245,12 @@ func (i VolumeMountPatchArgs) ToVolumeMountPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VolumeMountPatchOutput) } +func (i VolumeMountPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeMountPatch] { + return pulumix.Output[VolumeMountPatch]{ + OutputState: i.ToVolumeMountPatchOutputWithContext(ctx).OutputState, + } +} + // VolumeMountPatchArrayInput is an input type that accepts VolumeMountPatchArray and VolumeMountPatchArrayOutput values. // You can construct a concrete instance of `VolumeMountPatchArrayInput` via: // @@ -66737,6 +75276,12 @@ func (i VolumeMountPatchArray) ToVolumeMountPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeMountPatchArrayOutput) } +func (i VolumeMountPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeMountPatch] { + return pulumix.Output[[]VolumeMountPatch]{ + OutputState: i.ToVolumeMountPatchArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeMount describes a mounting of a Volume within a container. type VolumeMountPatchOutput struct{ *pulumi.OutputState } @@ -66752,6 +75297,12 @@ func (o VolumeMountPatchOutput) ToVolumeMountPatchOutputWithContext(ctx context. return o } +func (o VolumeMountPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeMountPatch] { + return pulumix.Output[VolumeMountPatch]{ + OutputState: o.OutputState, + } +} + // Path within the container at which the volume should be mounted. Must not contain ':'. func (o VolumeMountPatchOutput) MountPath() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeMountPatch) *string { return v.MountPath }).(pulumi.StringPtrOutput) @@ -66796,6 +75347,12 @@ func (o VolumeMountPatchArrayOutput) ToVolumeMountPatchArrayOutputWithContext(ct return o } +func (o VolumeMountPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeMountPatch] { + return pulumix.Output[[]VolumeMountPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeMountPatchArrayOutput) Index(i pulumi.IntInput) VolumeMountPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeMountPatch { return vs[0].([]VolumeMountPatch)[vs[1].(int)] @@ -66837,6 +75394,12 @@ func (i VolumeNodeAffinityArgs) ToVolumeNodeAffinityOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeAffinityOutput) } +func (i VolumeNodeAffinityArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeAffinity] { + return pulumix.Output[VolumeNodeAffinity]{ + OutputState: i.ToVolumeNodeAffinityOutputWithContext(ctx).OutputState, + } +} + func (i VolumeNodeAffinityArgs) ToVolumeNodeAffinityPtrOutput() VolumeNodeAffinityPtrOutput { return i.ToVolumeNodeAffinityPtrOutputWithContext(context.Background()) } @@ -66878,6 +75441,12 @@ func (i *volumeNodeAffinityPtrType) ToVolumeNodeAffinityPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeAffinityPtrOutput) } +func (i *volumeNodeAffinityPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeAffinity] { + return pulumix.Output[*VolumeNodeAffinity]{ + OutputState: i.ToVolumeNodeAffinityPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from. type VolumeNodeAffinityOutput struct{ *pulumi.OutputState } @@ -66903,6 +75472,12 @@ func (o VolumeNodeAffinityOutput) ToVolumeNodeAffinityPtrOutputWithContext(ctx c }).(VolumeNodeAffinityPtrOutput) } +func (o VolumeNodeAffinityOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeAffinity] { + return pulumix.Output[VolumeNodeAffinity]{ + OutputState: o.OutputState, + } +} + // required specifies hard node constraints that must be met. func (o VolumeNodeAffinityOutput) Required() NodeSelectorPtrOutput { return o.ApplyT(func(v VolumeNodeAffinity) *NodeSelector { return v.Required }).(NodeSelectorPtrOutput) @@ -66922,6 +75497,12 @@ func (o VolumeNodeAffinityPtrOutput) ToVolumeNodeAffinityPtrOutputWithContext(ct return o } +func (o VolumeNodeAffinityPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeAffinity] { + return pulumix.Output[*VolumeNodeAffinity]{ + OutputState: o.OutputState, + } +} + func (o VolumeNodeAffinityPtrOutput) Elem() VolumeNodeAffinityOutput { return o.ApplyT(func(v *VolumeNodeAffinity) VolumeNodeAffinity { if v != nil { @@ -66977,6 +75558,12 @@ func (i VolumeNodeAffinityPatchArgs) ToVolumeNodeAffinityPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeAffinityPatchOutput) } +func (i VolumeNodeAffinityPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeAffinityPatch] { + return pulumix.Output[VolumeNodeAffinityPatch]{ + OutputState: i.ToVolumeNodeAffinityPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeNodeAffinityPatchArgs) ToVolumeNodeAffinityPatchPtrOutput() VolumeNodeAffinityPatchPtrOutput { return i.ToVolumeNodeAffinityPatchPtrOutputWithContext(context.Background()) } @@ -67018,6 +75605,12 @@ func (i *volumeNodeAffinityPatchPtrType) ToVolumeNodeAffinityPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeAffinityPatchPtrOutput) } +func (i *volumeNodeAffinityPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeAffinityPatch] { + return pulumix.Output[*VolumeNodeAffinityPatch]{ + OutputState: i.ToVolumeNodeAffinityPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from. type VolumeNodeAffinityPatchOutput struct{ *pulumi.OutputState } @@ -67043,6 +75636,12 @@ func (o VolumeNodeAffinityPatchOutput) ToVolumeNodeAffinityPatchPtrOutputWithCon }).(VolumeNodeAffinityPatchPtrOutput) } +func (o VolumeNodeAffinityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeAffinityPatch] { + return pulumix.Output[VolumeNodeAffinityPatch]{ + OutputState: o.OutputState, + } +} + // required specifies hard node constraints that must be met. func (o VolumeNodeAffinityPatchOutput) Required() NodeSelectorPatchPtrOutput { return o.ApplyT(func(v VolumeNodeAffinityPatch) *NodeSelectorPatch { return v.Required }).(NodeSelectorPatchPtrOutput) @@ -67062,6 +75661,12 @@ func (o VolumeNodeAffinityPatchPtrOutput) ToVolumeNodeAffinityPatchPtrOutputWith return o } +func (o VolumeNodeAffinityPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeAffinityPatch] { + return pulumix.Output[*VolumeNodeAffinityPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeNodeAffinityPatchPtrOutput) Elem() VolumeNodeAffinityPatchOutput { return o.ApplyT(func(v *VolumeNodeAffinityPatch) VolumeNodeAffinityPatch { if v != nil { @@ -67259,6 +75864,12 @@ func (i VolumePatchArgs) ToVolumePatchOutputWithContext(ctx context.Context) Vol return pulumi.ToOutputWithContext(ctx, i).(VolumePatchOutput) } +func (i VolumePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumePatch] { + return pulumix.Output[VolumePatch]{ + OutputState: i.ToVolumePatchOutputWithContext(ctx).OutputState, + } +} + // VolumePatchArrayInput is an input type that accepts VolumePatchArray and VolumePatchArrayOutput values. // You can construct a concrete instance of `VolumePatchArrayInput` via: // @@ -67284,6 +75895,12 @@ func (i VolumePatchArray) ToVolumePatchArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(VolumePatchArrayOutput) } +func (i VolumePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumePatch] { + return pulumix.Output[[]VolumePatch]{ + OutputState: i.ToVolumePatchArrayOutputWithContext(ctx).OutputState, + } +} + // Volume represents a named volume in a pod that may be accessed by any container in the pod. type VolumePatchOutput struct{ *pulumi.OutputState } @@ -67299,6 +75916,12 @@ func (o VolumePatchOutput) ToVolumePatchOutputWithContext(ctx context.Context) V return o } +func (o VolumePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumePatch] { + return pulumix.Output[VolumePatch]{ + OutputState: o.OutputState, + } +} + // awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore func (o VolumePatchOutput) AwsElasticBlockStore() AWSElasticBlockStoreVolumeSourcePatchPtrOutput { return o.ApplyT(func(v VolumePatch) *AWSElasticBlockStoreVolumeSourcePatch { return v.AwsElasticBlockStore }).(AWSElasticBlockStoreVolumeSourcePatchPtrOutput) @@ -67479,6 +76102,12 @@ func (o VolumePatchArrayOutput) ToVolumePatchArrayOutputWithContext(ctx context. return o } +func (o VolumePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumePatch] { + return pulumix.Output[[]VolumePatch]{ + OutputState: o.OutputState, + } +} + func (o VolumePatchArrayOutput) Index(i pulumi.IntInput) VolumePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumePatch { return vs[0].([]VolumePatch)[vs[1].(int)] @@ -67532,6 +76161,12 @@ func (i VolumeProjectionArgs) ToVolumeProjectionOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VolumeProjectionOutput) } +func (i VolumeProjectionArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeProjection] { + return pulumix.Output[VolumeProjection]{ + OutputState: i.ToVolumeProjectionOutputWithContext(ctx).OutputState, + } +} + // VolumeProjectionArrayInput is an input type that accepts VolumeProjectionArray and VolumeProjectionArrayOutput values. // You can construct a concrete instance of `VolumeProjectionArrayInput` via: // @@ -67557,6 +76192,12 @@ func (i VolumeProjectionArray) ToVolumeProjectionArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeProjectionArrayOutput) } +func (i VolumeProjectionArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeProjection] { + return pulumix.Output[[]VolumeProjection]{ + OutputState: i.ToVolumeProjectionArrayOutputWithContext(ctx).OutputState, + } +} + // Projection that may be projected along with other supported volume types type VolumeProjectionOutput struct{ *pulumi.OutputState } @@ -67572,6 +76213,12 @@ func (o VolumeProjectionOutput) ToVolumeProjectionOutputWithContext(ctx context. return o } +func (o VolumeProjectionOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeProjection] { + return pulumix.Output[VolumeProjection]{ + OutputState: o.OutputState, + } +} + // configMap information about the configMap data to project func (o VolumeProjectionOutput) ConfigMap() ConfigMapProjectionPtrOutput { return o.ApplyT(func(v VolumeProjection) *ConfigMapProjection { return v.ConfigMap }).(ConfigMapProjectionPtrOutput) @@ -67606,6 +76253,12 @@ func (o VolumeProjectionArrayOutput) ToVolumeProjectionArrayOutputWithContext(ct return o } +func (o VolumeProjectionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeProjection] { + return pulumix.Output[[]VolumeProjection]{ + OutputState: o.OutputState, + } +} + func (o VolumeProjectionArrayOutput) Index(i pulumi.IntInput) VolumeProjectionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeProjection { return vs[0].([]VolumeProjection)[vs[1].(int)] @@ -67659,6 +76312,12 @@ func (i VolumeProjectionPatchArgs) ToVolumeProjectionPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(VolumeProjectionPatchOutput) } +func (i VolumeProjectionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeProjectionPatch] { + return pulumix.Output[VolumeProjectionPatch]{ + OutputState: i.ToVolumeProjectionPatchOutputWithContext(ctx).OutputState, + } +} + // VolumeProjectionPatchArrayInput is an input type that accepts VolumeProjectionPatchArray and VolumeProjectionPatchArrayOutput values. // You can construct a concrete instance of `VolumeProjectionPatchArrayInput` via: // @@ -67684,6 +76343,12 @@ func (i VolumeProjectionPatchArray) ToVolumeProjectionPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeProjectionPatchArrayOutput) } +func (i VolumeProjectionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeProjectionPatch] { + return pulumix.Output[[]VolumeProjectionPatch]{ + OutputState: i.ToVolumeProjectionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Projection that may be projected along with other supported volume types type VolumeProjectionPatchOutput struct{ *pulumi.OutputState } @@ -67699,6 +76364,12 @@ func (o VolumeProjectionPatchOutput) ToVolumeProjectionPatchOutputWithContext(ct return o } +func (o VolumeProjectionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeProjectionPatch] { + return pulumix.Output[VolumeProjectionPatch]{ + OutputState: o.OutputState, + } +} + // configMap information about the configMap data to project func (o VolumeProjectionPatchOutput) ConfigMap() ConfigMapProjectionPatchPtrOutput { return o.ApplyT(func(v VolumeProjectionPatch) *ConfigMapProjectionPatch { return v.ConfigMap }).(ConfigMapProjectionPatchPtrOutput) @@ -67733,6 +76404,12 @@ func (o VolumeProjectionPatchArrayOutput) ToVolumeProjectionPatchArrayOutputWith return o } +func (o VolumeProjectionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeProjectionPatch] { + return pulumix.Output[[]VolumeProjectionPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeProjectionPatchArrayOutput) Index(i pulumi.IntInput) VolumeProjectionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeProjectionPatch { return vs[0].([]VolumeProjectionPatch)[vs[1].(int)] @@ -67786,6 +76463,12 @@ func (i VsphereVirtualDiskVolumeSourceArgs) ToVsphereVirtualDiskVolumeSourceOutp return pulumi.ToOutputWithContext(ctx, i).(VsphereVirtualDiskVolumeSourceOutput) } +func (i VsphereVirtualDiskVolumeSourceArgs) ToOutput(ctx context.Context) pulumix.Output[VsphereVirtualDiskVolumeSource] { + return pulumix.Output[VsphereVirtualDiskVolumeSource]{ + OutputState: i.ToVsphereVirtualDiskVolumeSourceOutputWithContext(ctx).OutputState, + } +} + func (i VsphereVirtualDiskVolumeSourceArgs) ToVsphereVirtualDiskVolumeSourcePtrOutput() VsphereVirtualDiskVolumeSourcePtrOutput { return i.ToVsphereVirtualDiskVolumeSourcePtrOutputWithContext(context.Background()) } @@ -67827,6 +76510,12 @@ func (i *vsphereVirtualDiskVolumeSourcePtrType) ToVsphereVirtualDiskVolumeSource return pulumi.ToOutputWithContext(ctx, i).(VsphereVirtualDiskVolumeSourcePtrOutput) } +func (i *vsphereVirtualDiskVolumeSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*VsphereVirtualDiskVolumeSource] { + return pulumix.Output[*VsphereVirtualDiskVolumeSource]{ + OutputState: i.ToVsphereVirtualDiskVolumeSourcePtrOutputWithContext(ctx).OutputState, + } +} + // Represents a vSphere volume resource. type VsphereVirtualDiskVolumeSourceOutput struct{ *pulumi.OutputState } @@ -67852,6 +76541,12 @@ func (o VsphereVirtualDiskVolumeSourceOutput) ToVsphereVirtualDiskVolumeSourcePt }).(VsphereVirtualDiskVolumeSourcePtrOutput) } +func (o VsphereVirtualDiskVolumeSourceOutput) ToOutput(ctx context.Context) pulumix.Output[VsphereVirtualDiskVolumeSource] { + return pulumix.Output[VsphereVirtualDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + // fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o VsphereVirtualDiskVolumeSourceOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v VsphereVirtualDiskVolumeSource) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -67886,6 +76581,12 @@ func (o VsphereVirtualDiskVolumeSourcePtrOutput) ToVsphereVirtualDiskVolumeSourc return o } +func (o VsphereVirtualDiskVolumeSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VsphereVirtualDiskVolumeSource] { + return pulumix.Output[*VsphereVirtualDiskVolumeSource]{ + OutputState: o.OutputState, + } +} + func (o VsphereVirtualDiskVolumeSourcePtrOutput) Elem() VsphereVirtualDiskVolumeSourceOutput { return o.ApplyT(func(v *VsphereVirtualDiskVolumeSource) VsphereVirtualDiskVolumeSource { if v != nil { @@ -67983,6 +76684,12 @@ func (i VsphereVirtualDiskVolumeSourcePatchArgs) ToVsphereVirtualDiskVolumeSourc return pulumi.ToOutputWithContext(ctx, i).(VsphereVirtualDiskVolumeSourcePatchOutput) } +func (i VsphereVirtualDiskVolumeSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VsphereVirtualDiskVolumeSourcePatch] { + return pulumix.Output[VsphereVirtualDiskVolumeSourcePatch]{ + OutputState: i.ToVsphereVirtualDiskVolumeSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i VsphereVirtualDiskVolumeSourcePatchArgs) ToVsphereVirtualDiskVolumeSourcePatchPtrOutput() VsphereVirtualDiskVolumeSourcePatchPtrOutput { return i.ToVsphereVirtualDiskVolumeSourcePatchPtrOutputWithContext(context.Background()) } @@ -68024,6 +76731,12 @@ func (i *vsphereVirtualDiskVolumeSourcePatchPtrType) ToVsphereVirtualDiskVolumeS return pulumi.ToOutputWithContext(ctx, i).(VsphereVirtualDiskVolumeSourcePatchPtrOutput) } +func (i *vsphereVirtualDiskVolumeSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VsphereVirtualDiskVolumeSourcePatch] { + return pulumix.Output[*VsphereVirtualDiskVolumeSourcePatch]{ + OutputState: i.ToVsphereVirtualDiskVolumeSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // Represents a vSphere volume resource. type VsphereVirtualDiskVolumeSourcePatchOutput struct{ *pulumi.OutputState } @@ -68049,6 +76762,12 @@ func (o VsphereVirtualDiskVolumeSourcePatchOutput) ToVsphereVirtualDiskVolumeSou }).(VsphereVirtualDiskVolumeSourcePatchPtrOutput) } +func (o VsphereVirtualDiskVolumeSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VsphereVirtualDiskVolumeSourcePatch] { + return pulumix.Output[VsphereVirtualDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + // fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. func (o VsphereVirtualDiskVolumeSourcePatchOutput) FsType() pulumi.StringPtrOutput { return o.ApplyT(func(v VsphereVirtualDiskVolumeSourcePatch) *string { return v.FsType }).(pulumi.StringPtrOutput) @@ -68083,6 +76802,12 @@ func (o VsphereVirtualDiskVolumeSourcePatchPtrOutput) ToVsphereVirtualDiskVolume return o } +func (o VsphereVirtualDiskVolumeSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VsphereVirtualDiskVolumeSourcePatch] { + return pulumix.Output[*VsphereVirtualDiskVolumeSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o VsphereVirtualDiskVolumeSourcePatchPtrOutput) Elem() VsphereVirtualDiskVolumeSourcePatchOutput { return o.ApplyT(func(v *VsphereVirtualDiskVolumeSourcePatch) VsphereVirtualDiskVolumeSourcePatch { if v != nil { @@ -68172,6 +76897,12 @@ func (i WeightedPodAffinityTermArgs) ToWeightedPodAffinityTermOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(WeightedPodAffinityTermOutput) } +func (i WeightedPodAffinityTermArgs) ToOutput(ctx context.Context) pulumix.Output[WeightedPodAffinityTerm] { + return pulumix.Output[WeightedPodAffinityTerm]{ + OutputState: i.ToWeightedPodAffinityTermOutputWithContext(ctx).OutputState, + } +} + // WeightedPodAffinityTermArrayInput is an input type that accepts WeightedPodAffinityTermArray and WeightedPodAffinityTermArrayOutput values. // You can construct a concrete instance of `WeightedPodAffinityTermArrayInput` via: // @@ -68197,6 +76928,12 @@ func (i WeightedPodAffinityTermArray) ToWeightedPodAffinityTermArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(WeightedPodAffinityTermArrayOutput) } +func (i WeightedPodAffinityTermArray) ToOutput(ctx context.Context) pulumix.Output[[]WeightedPodAffinityTerm] { + return pulumix.Output[[]WeightedPodAffinityTerm]{ + OutputState: i.ToWeightedPodAffinityTermArrayOutputWithContext(ctx).OutputState, + } +} + // The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) type WeightedPodAffinityTermOutput struct{ *pulumi.OutputState } @@ -68212,6 +76949,12 @@ func (o WeightedPodAffinityTermOutput) ToWeightedPodAffinityTermOutputWithContex return o } +func (o WeightedPodAffinityTermOutput) ToOutput(ctx context.Context) pulumix.Output[WeightedPodAffinityTerm] { + return pulumix.Output[WeightedPodAffinityTerm]{ + OutputState: o.OutputState, + } +} + // Required. A pod affinity term, associated with the corresponding weight. func (o WeightedPodAffinityTermOutput) PodAffinityTerm() PodAffinityTermOutput { return o.ApplyT(func(v WeightedPodAffinityTerm) PodAffinityTerm { return v.PodAffinityTerm }).(PodAffinityTermOutput) @@ -68236,6 +76979,12 @@ func (o WeightedPodAffinityTermArrayOutput) ToWeightedPodAffinityTermArrayOutput return o } +func (o WeightedPodAffinityTermArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]WeightedPodAffinityTerm] { + return pulumix.Output[[]WeightedPodAffinityTerm]{ + OutputState: o.OutputState, + } +} + func (o WeightedPodAffinityTermArrayOutput) Index(i pulumi.IntInput) WeightedPodAffinityTermOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) WeightedPodAffinityTerm { return vs[0].([]WeightedPodAffinityTerm)[vs[1].(int)] @@ -68281,6 +77030,12 @@ func (i WeightedPodAffinityTermPatchArgs) ToWeightedPodAffinityTermPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(WeightedPodAffinityTermPatchOutput) } +func (i WeightedPodAffinityTermPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WeightedPodAffinityTermPatch] { + return pulumix.Output[WeightedPodAffinityTermPatch]{ + OutputState: i.ToWeightedPodAffinityTermPatchOutputWithContext(ctx).OutputState, + } +} + // WeightedPodAffinityTermPatchArrayInput is an input type that accepts WeightedPodAffinityTermPatchArray and WeightedPodAffinityTermPatchArrayOutput values. // You can construct a concrete instance of `WeightedPodAffinityTermPatchArrayInput` via: // @@ -68306,6 +77061,12 @@ func (i WeightedPodAffinityTermPatchArray) ToWeightedPodAffinityTermPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(WeightedPodAffinityTermPatchArrayOutput) } +func (i WeightedPodAffinityTermPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]WeightedPodAffinityTermPatch] { + return pulumix.Output[[]WeightedPodAffinityTermPatch]{ + OutputState: i.ToWeightedPodAffinityTermPatchArrayOutputWithContext(ctx).OutputState, + } +} + // The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) type WeightedPodAffinityTermPatchOutput struct{ *pulumi.OutputState } @@ -68321,6 +77082,12 @@ func (o WeightedPodAffinityTermPatchOutput) ToWeightedPodAffinityTermPatchOutput return o } +func (o WeightedPodAffinityTermPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WeightedPodAffinityTermPatch] { + return pulumix.Output[WeightedPodAffinityTermPatch]{ + OutputState: o.OutputState, + } +} + // Required. A pod affinity term, associated with the corresponding weight. func (o WeightedPodAffinityTermPatchOutput) PodAffinityTerm() PodAffinityTermPatchPtrOutput { return o.ApplyT(func(v WeightedPodAffinityTermPatch) *PodAffinityTermPatch { return v.PodAffinityTerm }).(PodAffinityTermPatchPtrOutput) @@ -68345,6 +77112,12 @@ func (o WeightedPodAffinityTermPatchArrayOutput) ToWeightedPodAffinityTermPatchA return o } +func (o WeightedPodAffinityTermPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]WeightedPodAffinityTermPatch] { + return pulumix.Output[[]WeightedPodAffinityTermPatch]{ + OutputState: o.OutputState, + } +} + func (o WeightedPodAffinityTermPatchArrayOutput) Index(i pulumi.IntInput) WeightedPodAffinityTermPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) WeightedPodAffinityTermPatch { return vs[0].([]WeightedPodAffinityTermPatch)[vs[1].(int)] @@ -68398,6 +77171,12 @@ func (i WindowsSecurityContextOptionsArgs) ToWindowsSecurityContextOptionsOutput return pulumi.ToOutputWithContext(ctx, i).(WindowsSecurityContextOptionsOutput) } +func (i WindowsSecurityContextOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[WindowsSecurityContextOptions] { + return pulumix.Output[WindowsSecurityContextOptions]{ + OutputState: i.ToWindowsSecurityContextOptionsOutputWithContext(ctx).OutputState, + } +} + func (i WindowsSecurityContextOptionsArgs) ToWindowsSecurityContextOptionsPtrOutput() WindowsSecurityContextOptionsPtrOutput { return i.ToWindowsSecurityContextOptionsPtrOutputWithContext(context.Background()) } @@ -68439,6 +77218,12 @@ func (i *windowsSecurityContextOptionsPtrType) ToWindowsSecurityContextOptionsPt return pulumi.ToOutputWithContext(ctx, i).(WindowsSecurityContextOptionsPtrOutput) } +func (i *windowsSecurityContextOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*WindowsSecurityContextOptions] { + return pulumix.Output[*WindowsSecurityContextOptions]{ + OutputState: i.ToWindowsSecurityContextOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // WindowsSecurityContextOptions contain Windows-specific options and credentials. type WindowsSecurityContextOptionsOutput struct{ *pulumi.OutputState } @@ -68464,6 +77249,12 @@ func (o WindowsSecurityContextOptionsOutput) ToWindowsSecurityContextOptionsPtrO }).(WindowsSecurityContextOptionsPtrOutput) } +func (o WindowsSecurityContextOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[WindowsSecurityContextOptions] { + return pulumix.Output[WindowsSecurityContextOptions]{ + OutputState: o.OutputState, + } +} + // GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. func (o WindowsSecurityContextOptionsOutput) GmsaCredentialSpec() pulumi.StringPtrOutput { return o.ApplyT(func(v WindowsSecurityContextOptions) *string { return v.GmsaCredentialSpec }).(pulumi.StringPtrOutput) @@ -68498,6 +77289,12 @@ func (o WindowsSecurityContextOptionsPtrOutput) ToWindowsSecurityContextOptionsP return o } +func (o WindowsSecurityContextOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WindowsSecurityContextOptions] { + return pulumix.Output[*WindowsSecurityContextOptions]{ + OutputState: o.OutputState, + } +} + func (o WindowsSecurityContextOptionsPtrOutput) Elem() WindowsSecurityContextOptionsOutput { return o.ApplyT(func(v *WindowsSecurityContextOptions) WindowsSecurityContextOptions { if v != nil { @@ -68595,6 +77392,12 @@ func (i WindowsSecurityContextOptionsPatchArgs) ToWindowsSecurityContextOptionsP return pulumi.ToOutputWithContext(ctx, i).(WindowsSecurityContextOptionsPatchOutput) } +func (i WindowsSecurityContextOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WindowsSecurityContextOptionsPatch] { + return pulumix.Output[WindowsSecurityContextOptionsPatch]{ + OutputState: i.ToWindowsSecurityContextOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i WindowsSecurityContextOptionsPatchArgs) ToWindowsSecurityContextOptionsPatchPtrOutput() WindowsSecurityContextOptionsPatchPtrOutput { return i.ToWindowsSecurityContextOptionsPatchPtrOutputWithContext(context.Background()) } @@ -68636,6 +77439,12 @@ func (i *windowsSecurityContextOptionsPatchPtrType) ToWindowsSecurityContextOpti return pulumi.ToOutputWithContext(ctx, i).(WindowsSecurityContextOptionsPatchPtrOutput) } +func (i *windowsSecurityContextOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*WindowsSecurityContextOptionsPatch] { + return pulumix.Output[*WindowsSecurityContextOptionsPatch]{ + OutputState: i.ToWindowsSecurityContextOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // WindowsSecurityContextOptions contain Windows-specific options and credentials. type WindowsSecurityContextOptionsPatchOutput struct{ *pulumi.OutputState } @@ -68661,6 +77470,12 @@ func (o WindowsSecurityContextOptionsPatchOutput) ToWindowsSecurityContextOption }).(WindowsSecurityContextOptionsPatchPtrOutput) } +func (o WindowsSecurityContextOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WindowsSecurityContextOptionsPatch] { + return pulumix.Output[WindowsSecurityContextOptionsPatch]{ + OutputState: o.OutputState, + } +} + // GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. func (o WindowsSecurityContextOptionsPatchOutput) GmsaCredentialSpec() pulumi.StringPtrOutput { return o.ApplyT(func(v WindowsSecurityContextOptionsPatch) *string { return v.GmsaCredentialSpec }).(pulumi.StringPtrOutput) @@ -68695,6 +77510,12 @@ func (o WindowsSecurityContextOptionsPatchPtrOutput) ToWindowsSecurityContextOpt return o } +func (o WindowsSecurityContextOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*WindowsSecurityContextOptionsPatch] { + return pulumix.Output[*WindowsSecurityContextOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o WindowsSecurityContextOptionsPatchPtrOutput) Elem() WindowsSecurityContextOptionsPatchOutput { return o.ApplyT(func(v *WindowsSecurityContextOptionsPatch) WindowsSecurityContextOptionsPatch { if v != nil { diff --git a/sdk/go/kubernetes/core/v1/replicationController.go b/sdk/go/kubernetes/core/v1/replicationController.go index fbfa2c5a0f..efa8b5c4b4 100644 --- a/sdk/go/kubernetes/core/v1/replicationController.go +++ b/sdk/go/kubernetes/core/v1/replicationController.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicationController represents the configuration of a replication controller. @@ -115,6 +116,12 @@ func (i *ReplicationController) ToReplicationControllerOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerOutput) } +func (i *ReplicationController) ToOutput(ctx context.Context) pulumix.Output[*ReplicationController] { + return pulumix.Output[*ReplicationController]{ + OutputState: i.ToReplicationControllerOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerArrayInput is an input type that accepts ReplicationControllerArray and ReplicationControllerArrayOutput values. // You can construct a concrete instance of `ReplicationControllerArrayInput` via: // @@ -140,6 +147,12 @@ func (i ReplicationControllerArray) ToReplicationControllerArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerArrayOutput) } +func (i ReplicationControllerArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicationController] { + return pulumix.Output[[]*ReplicationController]{ + OutputState: i.ToReplicationControllerArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerMapInput is an input type that accepts ReplicationControllerMap and ReplicationControllerMapOutput values. // You can construct a concrete instance of `ReplicationControllerMapInput` via: // @@ -165,6 +178,12 @@ func (i ReplicationControllerMap) ToReplicationControllerMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerMapOutput) } +func (i ReplicationControllerMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicationController] { + return pulumix.Output[map[string]*ReplicationController]{ + OutputState: i.ToReplicationControllerMapOutputWithContext(ctx).OutputState, + } +} + type ReplicationControllerOutput struct{ *pulumi.OutputState } func (ReplicationControllerOutput) ElementType() reflect.Type { @@ -179,6 +198,12 @@ func (o ReplicationControllerOutput) ToReplicationControllerOutputWithContext(ct return o } +func (o ReplicationControllerOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationController] { + return pulumix.Output[*ReplicationController]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicationControllerOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicationController) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -218,6 +243,12 @@ func (o ReplicationControllerArrayOutput) ToReplicationControllerArrayOutputWith return o } +func (o ReplicationControllerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicationController] { + return pulumix.Output[[]*ReplicationController]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerArrayOutput) Index(i pulumi.IntInput) ReplicationControllerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicationController { return vs[0].([]*ReplicationController)[vs[1].(int)] @@ -238,6 +269,12 @@ func (o ReplicationControllerMapOutput) ToReplicationControllerMapOutputWithCont return o } +func (o ReplicationControllerMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicationController] { + return pulumix.Output[map[string]*ReplicationController]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerMapOutput) MapIndex(k pulumi.StringInput) ReplicationControllerOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicationController { return vs[0].(map[string]*ReplicationController)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/replicationControllerList.go b/sdk/go/kubernetes/core/v1/replicationControllerList.go index add74454fb..35fcb27030 100644 --- a/sdk/go/kubernetes/core/v1/replicationControllerList.go +++ b/sdk/go/kubernetes/core/v1/replicationControllerList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicationControllerList is a collection of replication controllers. @@ -117,6 +118,12 @@ func (i *ReplicationControllerList) ToReplicationControllerListOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerListOutput) } +func (i *ReplicationControllerList) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerList] { + return pulumix.Output[*ReplicationControllerList]{ + OutputState: i.ToReplicationControllerListOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerListArrayInput is an input type that accepts ReplicationControllerListArray and ReplicationControllerListArrayOutput values. // You can construct a concrete instance of `ReplicationControllerListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ReplicationControllerListArray) ToReplicationControllerListArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerListArrayOutput) } +func (i ReplicationControllerListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicationControllerList] { + return pulumix.Output[[]*ReplicationControllerList]{ + OutputState: i.ToReplicationControllerListArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerListMapInput is an input type that accepts ReplicationControllerListMap and ReplicationControllerListMapOutput values. // You can construct a concrete instance of `ReplicationControllerListMapInput` via: // @@ -167,6 +180,12 @@ func (i ReplicationControllerListMap) ToReplicationControllerListMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerListMapOutput) } +func (i ReplicationControllerListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicationControllerList] { + return pulumix.Output[map[string]*ReplicationControllerList]{ + OutputState: i.ToReplicationControllerListMapOutputWithContext(ctx).OutputState, + } +} + type ReplicationControllerListOutput struct{ *pulumi.OutputState } func (ReplicationControllerListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ReplicationControllerListOutput) ToReplicationControllerListOutputWithCo return o } +func (o ReplicationControllerListOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerList] { + return pulumix.Output[*ReplicationControllerList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicationControllerListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicationControllerList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ReplicationControllerListArrayOutput) ToReplicationControllerListArrayOu return o } +func (o ReplicationControllerListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicationControllerList] { + return pulumix.Output[[]*ReplicationControllerList]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerListArrayOutput) Index(i pulumi.IntInput) ReplicationControllerListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicationControllerList { return vs[0].([]*ReplicationControllerList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ReplicationControllerListMapOutput) ToReplicationControllerListMapOutput return o } +func (o ReplicationControllerListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicationControllerList] { + return pulumix.Output[map[string]*ReplicationControllerList]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerListMapOutput) MapIndex(k pulumi.StringInput) ReplicationControllerListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicationControllerList { return vs[0].(map[string]*ReplicationControllerList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/replicationControllerPatch.go b/sdk/go/kubernetes/core/v1/replicationControllerPatch.go index 30705ac8b6..a9823ccad4 100644 --- a/sdk/go/kubernetes/core/v1/replicationControllerPatch.go +++ b/sdk/go/kubernetes/core/v1/replicationControllerPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -121,6 +122,12 @@ func (i *ReplicationControllerPatch) ToReplicationControllerPatchOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerPatchOutput) } +func (i *ReplicationControllerPatch) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerPatch] { + return pulumix.Output[*ReplicationControllerPatch]{ + OutputState: i.ToReplicationControllerPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerPatchArrayInput is an input type that accepts ReplicationControllerPatchArray and ReplicationControllerPatchArrayOutput values. // You can construct a concrete instance of `ReplicationControllerPatchArrayInput` via: // @@ -146,6 +153,12 @@ func (i ReplicationControllerPatchArray) ToReplicationControllerPatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerPatchArrayOutput) } +func (i ReplicationControllerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicationControllerPatch] { + return pulumix.Output[[]*ReplicationControllerPatch]{ + OutputState: i.ToReplicationControllerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicationControllerPatchMapInput is an input type that accepts ReplicationControllerPatchMap and ReplicationControllerPatchMapOutput values. // You can construct a concrete instance of `ReplicationControllerPatchMapInput` via: // @@ -171,6 +184,12 @@ func (i ReplicationControllerPatchMap) ToReplicationControllerPatchMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(ReplicationControllerPatchMapOutput) } +func (i ReplicationControllerPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicationControllerPatch] { + return pulumix.Output[map[string]*ReplicationControllerPatch]{ + OutputState: i.ToReplicationControllerPatchMapOutputWithContext(ctx).OutputState, + } +} + type ReplicationControllerPatchOutput struct{ *pulumi.OutputState } func (ReplicationControllerPatchOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o ReplicationControllerPatchOutput) ToReplicationControllerPatchOutputWith return o } +func (o ReplicationControllerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicationControllerPatch] { + return pulumix.Output[*ReplicationControllerPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicationControllerPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ReplicationControllerPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -224,6 +249,12 @@ func (o ReplicationControllerPatchArrayOutput) ToReplicationControllerPatchArray return o } +func (o ReplicationControllerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicationControllerPatch] { + return pulumix.Output[[]*ReplicationControllerPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerPatchArrayOutput) Index(i pulumi.IntInput) ReplicationControllerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicationControllerPatch { return vs[0].([]*ReplicationControllerPatch)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o ReplicationControllerPatchMapOutput) ToReplicationControllerPatchMapOutp return o } +func (o ReplicationControllerPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicationControllerPatch] { + return pulumix.Output[map[string]*ReplicationControllerPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicationControllerPatchMapOutput) MapIndex(k pulumi.StringInput) ReplicationControllerPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicationControllerPatch { return vs[0].(map[string]*ReplicationControllerPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/resourceQuota.go b/sdk/go/kubernetes/core/v1/resourceQuota.go index 08d7473e94..5a5551b371 100644 --- a/sdk/go/kubernetes/core/v1/resourceQuota.go +++ b/sdk/go/kubernetes/core/v1/resourceQuota.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceQuota sets aggregate quota restrictions enforced per namespace @@ -115,6 +116,12 @@ func (i *ResourceQuota) ToResourceQuotaOutputWithContext(ctx context.Context) Re return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaOutput) } +func (i *ResourceQuota) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuota] { + return pulumix.Output[*ResourceQuota]{ + OutputState: i.ToResourceQuotaOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaArrayInput is an input type that accepts ResourceQuotaArray and ResourceQuotaArrayOutput values. // You can construct a concrete instance of `ResourceQuotaArrayInput` via: // @@ -140,6 +147,12 @@ func (i ResourceQuotaArray) ToResourceQuotaArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaArrayOutput) } +func (i ResourceQuotaArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceQuota] { + return pulumix.Output[[]*ResourceQuota]{ + OutputState: i.ToResourceQuotaArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaMapInput is an input type that accepts ResourceQuotaMap and ResourceQuotaMapOutput values. // You can construct a concrete instance of `ResourceQuotaMapInput` via: // @@ -165,6 +178,12 @@ func (i ResourceQuotaMap) ToResourceQuotaMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaMapOutput) } +func (i ResourceQuotaMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceQuota] { + return pulumix.Output[map[string]*ResourceQuota]{ + OutputState: i.ToResourceQuotaMapOutputWithContext(ctx).OutputState, + } +} + type ResourceQuotaOutput struct{ *pulumi.OutputState } func (ResourceQuotaOutput) ElementType() reflect.Type { @@ -179,6 +198,12 @@ func (o ResourceQuotaOutput) ToResourceQuotaOutputWithContext(ctx context.Contex return o } +func (o ResourceQuotaOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuota] { + return pulumix.Output[*ResourceQuota]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceQuotaOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceQuota) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -218,6 +243,12 @@ func (o ResourceQuotaArrayOutput) ToResourceQuotaArrayOutputWithContext(ctx cont return o } +func (o ResourceQuotaArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceQuota] { + return pulumix.Output[[]*ResourceQuota]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaArrayOutput) Index(i pulumi.IntInput) ResourceQuotaOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceQuota { return vs[0].([]*ResourceQuota)[vs[1].(int)] @@ -238,6 +269,12 @@ func (o ResourceQuotaMapOutput) ToResourceQuotaMapOutputWithContext(ctx context. return o } +func (o ResourceQuotaMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceQuota] { + return pulumix.Output[map[string]*ResourceQuota]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaMapOutput) MapIndex(k pulumi.StringInput) ResourceQuotaOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceQuota { return vs[0].(map[string]*ResourceQuota)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/resourceQuotaList.go b/sdk/go/kubernetes/core/v1/resourceQuotaList.go index 7dfe379300..eefdec0d97 100644 --- a/sdk/go/kubernetes/core/v1/resourceQuotaList.go +++ b/sdk/go/kubernetes/core/v1/resourceQuotaList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceQuotaList is a list of ResourceQuota items. @@ -117,6 +118,12 @@ func (i *ResourceQuotaList) ToResourceQuotaListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaListOutput) } +func (i *ResourceQuotaList) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaList] { + return pulumix.Output[*ResourceQuotaList]{ + OutputState: i.ToResourceQuotaListOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaListArrayInput is an input type that accepts ResourceQuotaListArray and ResourceQuotaListArrayOutput values. // You can construct a concrete instance of `ResourceQuotaListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceQuotaListArray) ToResourceQuotaListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaListArrayOutput) } +func (i ResourceQuotaListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceQuotaList] { + return pulumix.Output[[]*ResourceQuotaList]{ + OutputState: i.ToResourceQuotaListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaListMapInput is an input type that accepts ResourceQuotaListMap and ResourceQuotaListMapOutput values. // You can construct a concrete instance of `ResourceQuotaListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceQuotaListMap) ToResourceQuotaListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaListMapOutput) } +func (i ResourceQuotaListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceQuotaList] { + return pulumix.Output[map[string]*ResourceQuotaList]{ + OutputState: i.ToResourceQuotaListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceQuotaListOutput struct{ *pulumi.OutputState } func (ResourceQuotaListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceQuotaListOutput) ToResourceQuotaListOutputWithContext(ctx contex return o } +func (o ResourceQuotaListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaList] { + return pulumix.Output[*ResourceQuotaList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceQuotaListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceQuotaList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceQuotaListArrayOutput) ToResourceQuotaListArrayOutputWithContext( return o } +func (o ResourceQuotaListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceQuotaList] { + return pulumix.Output[[]*ResourceQuotaList]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaListArrayOutput) Index(i pulumi.IntInput) ResourceQuotaListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceQuotaList { return vs[0].([]*ResourceQuotaList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceQuotaListMapOutput) ToResourceQuotaListMapOutputWithContext(ctx return o } +func (o ResourceQuotaListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceQuotaList] { + return pulumix.Output[map[string]*ResourceQuotaList]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaListMapOutput) MapIndex(k pulumi.StringInput) ResourceQuotaListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceQuotaList { return vs[0].(map[string]*ResourceQuotaList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/resourceQuotaPatch.go b/sdk/go/kubernetes/core/v1/resourceQuotaPatch.go index 98e316ff2b..513d53ede9 100644 --- a/sdk/go/kubernetes/core/v1/resourceQuotaPatch.go +++ b/sdk/go/kubernetes/core/v1/resourceQuotaPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -121,6 +122,12 @@ func (i *ResourceQuotaPatch) ToResourceQuotaPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaPatchOutput) } +func (i *ResourceQuotaPatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaPatch] { + return pulumix.Output[*ResourceQuotaPatch]{ + OutputState: i.ToResourceQuotaPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaPatchArrayInput is an input type that accepts ResourceQuotaPatchArray and ResourceQuotaPatchArrayOutput values. // You can construct a concrete instance of `ResourceQuotaPatchArrayInput` via: // @@ -146,6 +153,12 @@ func (i ResourceQuotaPatchArray) ToResourceQuotaPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaPatchArrayOutput) } +func (i ResourceQuotaPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceQuotaPatch] { + return pulumix.Output[[]*ResourceQuotaPatch]{ + OutputState: i.ToResourceQuotaPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceQuotaPatchMapInput is an input type that accepts ResourceQuotaPatchMap and ResourceQuotaPatchMapOutput values. // You can construct a concrete instance of `ResourceQuotaPatchMapInput` via: // @@ -171,6 +184,12 @@ func (i ResourceQuotaPatchMap) ToResourceQuotaPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceQuotaPatchMapOutput) } +func (i ResourceQuotaPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceQuotaPatch] { + return pulumix.Output[map[string]*ResourceQuotaPatch]{ + OutputState: i.ToResourceQuotaPatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceQuotaPatchOutput struct{ *pulumi.OutputState } func (ResourceQuotaPatchOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o ResourceQuotaPatchOutput) ToResourceQuotaPatchOutputWithContext(ctx cont return o } +func (o ResourceQuotaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceQuotaPatch] { + return pulumix.Output[*ResourceQuotaPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceQuotaPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceQuotaPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -224,6 +249,12 @@ func (o ResourceQuotaPatchArrayOutput) ToResourceQuotaPatchArrayOutputWithContex return o } +func (o ResourceQuotaPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceQuotaPatch] { + return pulumix.Output[[]*ResourceQuotaPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaPatchArrayOutput) Index(i pulumi.IntInput) ResourceQuotaPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceQuotaPatch { return vs[0].([]*ResourceQuotaPatch)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o ResourceQuotaPatchMapOutput) ToResourceQuotaPatchMapOutputWithContext(ct return o } +func (o ResourceQuotaPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceQuotaPatch] { + return pulumix.Output[map[string]*ResourceQuotaPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceQuotaPatchMapOutput) MapIndex(k pulumi.StringInput) ResourceQuotaPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceQuotaPatch { return vs[0].(map[string]*ResourceQuotaPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/secret.go b/sdk/go/kubernetes/core/v1/secret.go index 0f8be4820d..217199c2c5 100644 --- a/sdk/go/kubernetes/core/v1/secret.go +++ b/sdk/go/kubernetes/core/v1/secret.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes. @@ -152,6 +153,12 @@ func (i *Secret) ToSecretOutputWithContext(ctx context.Context) SecretOutput { return pulumi.ToOutputWithContext(ctx, i).(SecretOutput) } +func (i *Secret) ToOutput(ctx context.Context) pulumix.Output[*Secret] { + return pulumix.Output[*Secret]{ + OutputState: i.ToSecretOutputWithContext(ctx).OutputState, + } +} + // SecretArrayInput is an input type that accepts SecretArray and SecretArrayOutput values. // You can construct a concrete instance of `SecretArrayInput` via: // @@ -177,6 +184,12 @@ func (i SecretArray) ToSecretArrayOutputWithContext(ctx context.Context) SecretA return pulumi.ToOutputWithContext(ctx, i).(SecretArrayOutput) } +func (i SecretArray) ToOutput(ctx context.Context) pulumix.Output[[]*Secret] { + return pulumix.Output[[]*Secret]{ + OutputState: i.ToSecretArrayOutputWithContext(ctx).OutputState, + } +} + // SecretMapInput is an input type that accepts SecretMap and SecretMapOutput values. // You can construct a concrete instance of `SecretMapInput` via: // @@ -202,6 +215,12 @@ func (i SecretMap) ToSecretMapOutputWithContext(ctx context.Context) SecretMapOu return pulumi.ToOutputWithContext(ctx, i).(SecretMapOutput) } +func (i SecretMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Secret] { + return pulumix.Output[map[string]*Secret]{ + OutputState: i.ToSecretMapOutputWithContext(ctx).OutputState, + } +} + type SecretOutput struct{ *pulumi.OutputState } func (SecretOutput) ElementType() reflect.Type { @@ -216,6 +235,12 @@ func (o SecretOutput) ToSecretOutputWithContext(ctx context.Context) SecretOutpu return o } +func (o SecretOutput) ToOutput(ctx context.Context) pulumix.Output[*Secret] { + return pulumix.Output[*Secret]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SecretOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Secret) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -265,6 +290,12 @@ func (o SecretArrayOutput) ToSecretArrayOutputWithContext(ctx context.Context) S return o } +func (o SecretArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Secret] { + return pulumix.Output[[]*Secret]{ + OutputState: o.OutputState, + } +} + func (o SecretArrayOutput) Index(i pulumi.IntInput) SecretOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Secret { return vs[0].([]*Secret)[vs[1].(int)] @@ -285,6 +316,12 @@ func (o SecretMapOutput) ToSecretMapOutputWithContext(ctx context.Context) Secre return o } +func (o SecretMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Secret] { + return pulumix.Output[map[string]*Secret]{ + OutputState: o.OutputState, + } +} + func (o SecretMapOutput) MapIndex(k pulumi.StringInput) SecretOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Secret { return vs[0].(map[string]*Secret)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/secretList.go b/sdk/go/kubernetes/core/v1/secretList.go index 3495e00916..270e321d88 100644 --- a/sdk/go/kubernetes/core/v1/secretList.go +++ b/sdk/go/kubernetes/core/v1/secretList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // SecretList is a list of Secret. @@ -117,6 +118,12 @@ func (i *SecretList) ToSecretListOutputWithContext(ctx context.Context) SecretLi return pulumi.ToOutputWithContext(ctx, i).(SecretListOutput) } +func (i *SecretList) ToOutput(ctx context.Context) pulumix.Output[*SecretList] { + return pulumix.Output[*SecretList]{ + OutputState: i.ToSecretListOutputWithContext(ctx).OutputState, + } +} + // SecretListArrayInput is an input type that accepts SecretListArray and SecretListArrayOutput values. // You can construct a concrete instance of `SecretListArrayInput` via: // @@ -142,6 +149,12 @@ func (i SecretListArray) ToSecretListArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(SecretListArrayOutput) } +func (i SecretListArray) ToOutput(ctx context.Context) pulumix.Output[[]*SecretList] { + return pulumix.Output[[]*SecretList]{ + OutputState: i.ToSecretListArrayOutputWithContext(ctx).OutputState, + } +} + // SecretListMapInput is an input type that accepts SecretListMap and SecretListMapOutput values. // You can construct a concrete instance of `SecretListMapInput` via: // @@ -167,6 +180,12 @@ func (i SecretListMap) ToSecretListMapOutputWithContext(ctx context.Context) Sec return pulumi.ToOutputWithContext(ctx, i).(SecretListMapOutput) } +func (i SecretListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*SecretList] { + return pulumix.Output[map[string]*SecretList]{ + OutputState: i.ToSecretListMapOutputWithContext(ctx).OutputState, + } +} + type SecretListOutput struct{ *pulumi.OutputState } func (SecretListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o SecretListOutput) ToSecretListOutputWithContext(ctx context.Context) Sec return o } +func (o SecretListOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretList] { + return pulumix.Output[*SecretList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SecretListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *SecretList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o SecretListArrayOutput) ToSecretListArrayOutputWithContext(ctx context.Co return o } +func (o SecretListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*SecretList] { + return pulumix.Output[[]*SecretList]{ + OutputState: o.OutputState, + } +} + func (o SecretListArrayOutput) Index(i pulumi.IntInput) SecretListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SecretList { return vs[0].([]*SecretList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o SecretListMapOutput) ToSecretListMapOutputWithContext(ctx context.Contex return o } +func (o SecretListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*SecretList] { + return pulumix.Output[map[string]*SecretList]{ + OutputState: o.OutputState, + } +} + func (o SecretListMapOutput) MapIndex(k pulumi.StringInput) SecretListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SecretList { return vs[0].(map[string]*SecretList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/secretPatch.go b/sdk/go/kubernetes/core/v1/secretPatch.go index 0c935b673a..1f56ceb465 100644 --- a/sdk/go/kubernetes/core/v1/secretPatch.go +++ b/sdk/go/kubernetes/core/v1/secretPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -147,6 +148,12 @@ func (i *SecretPatch) ToSecretPatchOutputWithContext(ctx context.Context) Secret return pulumi.ToOutputWithContext(ctx, i).(SecretPatchOutput) } +func (i *SecretPatch) ToOutput(ctx context.Context) pulumix.Output[*SecretPatch] { + return pulumix.Output[*SecretPatch]{ + OutputState: i.ToSecretPatchOutputWithContext(ctx).OutputState, + } +} + // SecretPatchArrayInput is an input type that accepts SecretPatchArray and SecretPatchArrayOutput values. // You can construct a concrete instance of `SecretPatchArrayInput` via: // @@ -172,6 +179,12 @@ func (i SecretPatchArray) ToSecretPatchArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(SecretPatchArrayOutput) } +func (i SecretPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*SecretPatch] { + return pulumix.Output[[]*SecretPatch]{ + OutputState: i.ToSecretPatchArrayOutputWithContext(ctx).OutputState, + } +} + // SecretPatchMapInput is an input type that accepts SecretPatchMap and SecretPatchMapOutput values. // You can construct a concrete instance of `SecretPatchMapInput` via: // @@ -197,6 +210,12 @@ func (i SecretPatchMap) ToSecretPatchMapOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SecretPatchMapOutput) } +func (i SecretPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*SecretPatch] { + return pulumix.Output[map[string]*SecretPatch]{ + OutputState: i.ToSecretPatchMapOutputWithContext(ctx).OutputState, + } +} + type SecretPatchOutput struct{ *pulumi.OutputState } func (SecretPatchOutput) ElementType() reflect.Type { @@ -211,6 +230,12 @@ func (o SecretPatchOutput) ToSecretPatchOutputWithContext(ctx context.Context) S return o } +func (o SecretPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*SecretPatch] { + return pulumix.Output[*SecretPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o SecretPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *SecretPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -260,6 +285,12 @@ func (o SecretPatchArrayOutput) ToSecretPatchArrayOutputWithContext(ctx context. return o } +func (o SecretPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*SecretPatch] { + return pulumix.Output[[]*SecretPatch]{ + OutputState: o.OutputState, + } +} + func (o SecretPatchArrayOutput) Index(i pulumi.IntInput) SecretPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SecretPatch { return vs[0].([]*SecretPatch)[vs[1].(int)] @@ -280,6 +311,12 @@ func (o SecretPatchMapOutput) ToSecretPatchMapOutputWithContext(ctx context.Cont return o } +func (o SecretPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*SecretPatch] { + return pulumix.Output[map[string]*SecretPatch]{ + OutputState: o.OutputState, + } +} + func (o SecretPatchMapOutput) MapIndex(k pulumi.StringInput) SecretPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SecretPatch { return vs[0].(map[string]*SecretPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/service.go b/sdk/go/kubernetes/core/v1/service.go index e6517047d8..935e3db74c 100644 --- a/sdk/go/kubernetes/core/v1/service.go +++ b/sdk/go/kubernetes/core/v1/service.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy. @@ -216,6 +217,12 @@ func (i *Service) ToServiceOutputWithContext(ctx context.Context) ServiceOutput return pulumi.ToOutputWithContext(ctx, i).(ServiceOutput) } +func (i *Service) ToOutput(ctx context.Context) pulumix.Output[*Service] { + return pulumix.Output[*Service]{ + OutputState: i.ToServiceOutputWithContext(ctx).OutputState, + } +} + // ServiceArrayInput is an input type that accepts ServiceArray and ServiceArrayOutput values. // You can construct a concrete instance of `ServiceArrayInput` via: // @@ -241,6 +248,12 @@ func (i ServiceArray) ToServiceArrayOutputWithContext(ctx context.Context) Servi return pulumi.ToOutputWithContext(ctx, i).(ServiceArrayOutput) } +func (i ServiceArray) ToOutput(ctx context.Context) pulumix.Output[[]*Service] { + return pulumix.Output[[]*Service]{ + OutputState: i.ToServiceArrayOutputWithContext(ctx).OutputState, + } +} + // ServiceMapInput is an input type that accepts ServiceMap and ServiceMapOutput values. // You can construct a concrete instance of `ServiceMapInput` via: // @@ -266,6 +279,12 @@ func (i ServiceMap) ToServiceMapOutputWithContext(ctx context.Context) ServiceMa return pulumi.ToOutputWithContext(ctx, i).(ServiceMapOutput) } +func (i ServiceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Service] { + return pulumix.Output[map[string]*Service]{ + OutputState: i.ToServiceMapOutputWithContext(ctx).OutputState, + } +} + type ServiceOutput struct{ *pulumi.OutputState } func (ServiceOutput) ElementType() reflect.Type { @@ -280,6 +299,12 @@ func (o ServiceOutput) ToServiceOutputWithContext(ctx context.Context) ServiceOu return o } +func (o ServiceOutput) ToOutput(ctx context.Context) pulumix.Output[*Service] { + return pulumix.Output[*Service]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Service) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -319,6 +344,12 @@ func (o ServiceArrayOutput) ToServiceArrayOutputWithContext(ctx context.Context) return o } +func (o ServiceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Service] { + return pulumix.Output[[]*Service]{ + OutputState: o.OutputState, + } +} + func (o ServiceArrayOutput) Index(i pulumi.IntInput) ServiceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Service { return vs[0].([]*Service)[vs[1].(int)] @@ -339,6 +370,12 @@ func (o ServiceMapOutput) ToServiceMapOutputWithContext(ctx context.Context) Ser return o } +func (o ServiceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Service] { + return pulumix.Output[map[string]*Service]{ + OutputState: o.OutputState, + } +} + func (o ServiceMapOutput) MapIndex(k pulumi.StringInput) ServiceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Service { return vs[0].(map[string]*Service)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/serviceAccount.go b/sdk/go/kubernetes/core/v1/serviceAccount.go index 91e6592fa4..04fc087bee 100644 --- a/sdk/go/kubernetes/core/v1/serviceAccount.go +++ b/sdk/go/kubernetes/core/v1/serviceAccount.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets @@ -125,6 +126,12 @@ func (i *ServiceAccount) ToServiceAccountOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountOutput) } +func (i *ServiceAccount) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccount] { + return pulumix.Output[*ServiceAccount]{ + OutputState: i.ToServiceAccountOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountArrayInput is an input type that accepts ServiceAccountArray and ServiceAccountArrayOutput values. // You can construct a concrete instance of `ServiceAccountArrayInput` via: // @@ -150,6 +157,12 @@ func (i ServiceAccountArray) ToServiceAccountArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountArrayOutput) } +func (i ServiceAccountArray) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceAccount] { + return pulumix.Output[[]*ServiceAccount]{ + OutputState: i.ToServiceAccountArrayOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountMapInput is an input type that accepts ServiceAccountMap and ServiceAccountMapOutput values. // You can construct a concrete instance of `ServiceAccountMapInput` via: // @@ -175,6 +188,12 @@ func (i ServiceAccountMap) ToServiceAccountMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountMapOutput) } +func (i ServiceAccountMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceAccount] { + return pulumix.Output[map[string]*ServiceAccount]{ + OutputState: i.ToServiceAccountMapOutputWithContext(ctx).OutputState, + } +} + type ServiceAccountOutput struct{ *pulumi.OutputState } func (ServiceAccountOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o ServiceAccountOutput) ToServiceAccountOutputWithContext(ctx context.Cont return o } +func (o ServiceAccountOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccount] { + return pulumix.Output[*ServiceAccount]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceAccountOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ServiceAccount) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -233,6 +258,12 @@ func (o ServiceAccountArrayOutput) ToServiceAccountArrayOutputWithContext(ctx co return o } +func (o ServiceAccountArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceAccount] { + return pulumix.Output[[]*ServiceAccount]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountArrayOutput) Index(i pulumi.IntInput) ServiceAccountOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceAccount { return vs[0].([]*ServiceAccount)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o ServiceAccountMapOutput) ToServiceAccountMapOutputWithContext(ctx contex return o } +func (o ServiceAccountMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceAccount] { + return pulumix.Output[map[string]*ServiceAccount]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountMapOutput) MapIndex(k pulumi.StringInput) ServiceAccountOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceAccount { return vs[0].(map[string]*ServiceAccount)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/serviceAccountList.go b/sdk/go/kubernetes/core/v1/serviceAccountList.go index 5800a5496f..cba62f0242 100644 --- a/sdk/go/kubernetes/core/v1/serviceAccountList.go +++ b/sdk/go/kubernetes/core/v1/serviceAccountList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ServiceAccountList is a list of ServiceAccount objects @@ -117,6 +118,12 @@ func (i *ServiceAccountList) ToServiceAccountListOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountListOutput) } +func (i *ServiceAccountList) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountList] { + return pulumix.Output[*ServiceAccountList]{ + OutputState: i.ToServiceAccountListOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountListArrayInput is an input type that accepts ServiceAccountListArray and ServiceAccountListArrayOutput values. // You can construct a concrete instance of `ServiceAccountListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ServiceAccountListArray) ToServiceAccountListArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountListArrayOutput) } +func (i ServiceAccountListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceAccountList] { + return pulumix.Output[[]*ServiceAccountList]{ + OutputState: i.ToServiceAccountListArrayOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountListMapInput is an input type that accepts ServiceAccountListMap and ServiceAccountListMapOutput values. // You can construct a concrete instance of `ServiceAccountListMapInput` via: // @@ -167,6 +180,12 @@ func (i ServiceAccountListMap) ToServiceAccountListMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountListMapOutput) } +func (i ServiceAccountListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceAccountList] { + return pulumix.Output[map[string]*ServiceAccountList]{ + OutputState: i.ToServiceAccountListMapOutputWithContext(ctx).OutputState, + } +} + type ServiceAccountListOutput struct{ *pulumi.OutputState } func (ServiceAccountListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ServiceAccountListOutput) ToServiceAccountListOutputWithContext(ctx cont return o } +func (o ServiceAccountListOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountList] { + return pulumix.Output[*ServiceAccountList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceAccountListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ServiceAccountList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ServiceAccountListArrayOutput) ToServiceAccountListArrayOutputWithContex return o } +func (o ServiceAccountListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceAccountList] { + return pulumix.Output[[]*ServiceAccountList]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountListArrayOutput) Index(i pulumi.IntInput) ServiceAccountListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceAccountList { return vs[0].([]*ServiceAccountList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ServiceAccountListMapOutput) ToServiceAccountListMapOutputWithContext(ct return o } +func (o ServiceAccountListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceAccountList] { + return pulumix.Output[map[string]*ServiceAccountList]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountListMapOutput) MapIndex(k pulumi.StringInput) ServiceAccountListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceAccountList { return vs[0].(map[string]*ServiceAccountList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/serviceAccountPatch.go b/sdk/go/kubernetes/core/v1/serviceAccountPatch.go index 5c544454f1..73daf914b8 100644 --- a/sdk/go/kubernetes/core/v1/serviceAccountPatch.go +++ b/sdk/go/kubernetes/core/v1/serviceAccountPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -131,6 +132,12 @@ func (i *ServiceAccountPatch) ToServiceAccountPatchOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountPatchOutput) } +func (i *ServiceAccountPatch) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountPatch] { + return pulumix.Output[*ServiceAccountPatch]{ + OutputState: i.ToServiceAccountPatchOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountPatchArrayInput is an input type that accepts ServiceAccountPatchArray and ServiceAccountPatchArrayOutput values. // You can construct a concrete instance of `ServiceAccountPatchArrayInput` via: // @@ -156,6 +163,12 @@ func (i ServiceAccountPatchArray) ToServiceAccountPatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountPatchArrayOutput) } +func (i ServiceAccountPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceAccountPatch] { + return pulumix.Output[[]*ServiceAccountPatch]{ + OutputState: i.ToServiceAccountPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountPatchMapInput is an input type that accepts ServiceAccountPatchMap and ServiceAccountPatchMapOutput values. // You can construct a concrete instance of `ServiceAccountPatchMapInput` via: // @@ -181,6 +194,12 @@ func (i ServiceAccountPatchMap) ToServiceAccountPatchMapOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountPatchMapOutput) } +func (i ServiceAccountPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceAccountPatch] { + return pulumix.Output[map[string]*ServiceAccountPatch]{ + OutputState: i.ToServiceAccountPatchMapOutputWithContext(ctx).OutputState, + } +} + type ServiceAccountPatchOutput struct{ *pulumi.OutputState } func (ServiceAccountPatchOutput) ElementType() reflect.Type { @@ -195,6 +214,12 @@ func (o ServiceAccountPatchOutput) ToServiceAccountPatchOutputWithContext(ctx co return o } +func (o ServiceAccountPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountPatch] { + return pulumix.Output[*ServiceAccountPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceAccountPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ServiceAccountPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -239,6 +264,12 @@ func (o ServiceAccountPatchArrayOutput) ToServiceAccountPatchArrayOutputWithCont return o } +func (o ServiceAccountPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceAccountPatch] { + return pulumix.Output[[]*ServiceAccountPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountPatchArrayOutput) Index(i pulumi.IntInput) ServiceAccountPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceAccountPatch { return vs[0].([]*ServiceAccountPatch)[vs[1].(int)] @@ -259,6 +290,12 @@ func (o ServiceAccountPatchMapOutput) ToServiceAccountPatchMapOutputWithContext( return o } +func (o ServiceAccountPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceAccountPatch] { + return pulumix.Output[map[string]*ServiceAccountPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountPatchMapOutput) MapIndex(k pulumi.StringInput) ServiceAccountPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceAccountPatch { return vs[0].(map[string]*ServiceAccountPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/serviceList.go b/sdk/go/kubernetes/core/v1/serviceList.go index a907f9ecd3..b786ab6036 100644 --- a/sdk/go/kubernetes/core/v1/serviceList.go +++ b/sdk/go/kubernetes/core/v1/serviceList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ServiceList holds a list of services. @@ -117,6 +118,12 @@ func (i *ServiceList) ToServiceListOutputWithContext(ctx context.Context) Servic return pulumi.ToOutputWithContext(ctx, i).(ServiceListOutput) } +func (i *ServiceList) ToOutput(ctx context.Context) pulumix.Output[*ServiceList] { + return pulumix.Output[*ServiceList]{ + OutputState: i.ToServiceListOutputWithContext(ctx).OutputState, + } +} + // ServiceListArrayInput is an input type that accepts ServiceListArray and ServiceListArrayOutput values. // You can construct a concrete instance of `ServiceListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ServiceListArray) ToServiceListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ServiceListArrayOutput) } +func (i ServiceListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceList] { + return pulumix.Output[[]*ServiceList]{ + OutputState: i.ToServiceListArrayOutputWithContext(ctx).OutputState, + } +} + // ServiceListMapInput is an input type that accepts ServiceListMap and ServiceListMapOutput values. // You can construct a concrete instance of `ServiceListMapInput` via: // @@ -167,6 +180,12 @@ func (i ServiceListMap) ToServiceListMapOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(ServiceListMapOutput) } +func (i ServiceListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceList] { + return pulumix.Output[map[string]*ServiceList]{ + OutputState: i.ToServiceListMapOutputWithContext(ctx).OutputState, + } +} + type ServiceListOutput struct{ *pulumi.OutputState } func (ServiceListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ServiceListOutput) ToServiceListOutputWithContext(ctx context.Context) S return o } +func (o ServiceListOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceList] { + return pulumix.Output[*ServiceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServiceListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ServiceList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ServiceListArrayOutput) ToServiceListArrayOutputWithContext(ctx context. return o } +func (o ServiceListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ServiceList] { + return pulumix.Output[[]*ServiceList]{ + OutputState: o.OutputState, + } +} + func (o ServiceListArrayOutput) Index(i pulumi.IntInput) ServiceListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceList { return vs[0].([]*ServiceList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ServiceListMapOutput) ToServiceListMapOutputWithContext(ctx context.Cont return o } +func (o ServiceListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServiceList] { + return pulumix.Output[map[string]*ServiceList]{ + OutputState: o.OutputState, + } +} + func (o ServiceListMapOutput) MapIndex(k pulumi.StringInput) ServiceListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceList { return vs[0].(map[string]*ServiceList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/core/v1/servicePatch.go b/sdk/go/kubernetes/core/v1/servicePatch.go index 46c1db6428..9a5686e8fc 100644 --- a/sdk/go/kubernetes/core/v1/servicePatch.go +++ b/sdk/go/kubernetes/core/v1/servicePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -146,6 +147,12 @@ func (i *ServicePatch) ToServicePatchOutputWithContext(ctx context.Context) Serv return pulumi.ToOutputWithContext(ctx, i).(ServicePatchOutput) } +func (i *ServicePatch) ToOutput(ctx context.Context) pulumix.Output[*ServicePatch] { + return pulumix.Output[*ServicePatch]{ + OutputState: i.ToServicePatchOutputWithContext(ctx).OutputState, + } +} + // ServicePatchArrayInput is an input type that accepts ServicePatchArray and ServicePatchArrayOutput values. // You can construct a concrete instance of `ServicePatchArrayInput` via: // @@ -171,6 +178,12 @@ func (i ServicePatchArray) ToServicePatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ServicePatchArrayOutput) } +func (i ServicePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ServicePatch] { + return pulumix.Output[[]*ServicePatch]{ + OutputState: i.ToServicePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ServicePatchMapInput is an input type that accepts ServicePatchMap and ServicePatchMapOutput values. // You can construct a concrete instance of `ServicePatchMapInput` via: // @@ -196,6 +209,12 @@ func (i ServicePatchMap) ToServicePatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ServicePatchMapOutput) } +func (i ServicePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServicePatch] { + return pulumix.Output[map[string]*ServicePatch]{ + OutputState: i.ToServicePatchMapOutputWithContext(ctx).OutputState, + } +} + type ServicePatchOutput struct{ *pulumi.OutputState } func (ServicePatchOutput) ElementType() reflect.Type { @@ -210,6 +229,12 @@ func (o ServicePatchOutput) ToServicePatchOutputWithContext(ctx context.Context) return o } +func (o ServicePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ServicePatch] { + return pulumix.Output[*ServicePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ServicePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ServicePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -249,6 +274,12 @@ func (o ServicePatchArrayOutput) ToServicePatchArrayOutputWithContext(ctx contex return o } +func (o ServicePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ServicePatch] { + return pulumix.Output[[]*ServicePatch]{ + OutputState: o.OutputState, + } +} + func (o ServicePatchArrayOutput) Index(i pulumi.IntInput) ServicePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServicePatch { return vs[0].([]*ServicePatch)[vs[1].(int)] @@ -269,6 +300,12 @@ func (o ServicePatchMapOutput) ToServicePatchMapOutputWithContext(ctx context.Co return o } +func (o ServicePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ServicePatch] { + return pulumix.Output[map[string]*ServicePatch]{ + OutputState: o.OutputState, + } +} + func (o ServicePatchMapOutput) MapIndex(k pulumi.StringInput) ServicePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServicePatch { return vs[0].(map[string]*ServicePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1/endpointSlice.go b/sdk/go/kubernetes/discovery/v1/endpointSlice.go index a870dc4ab8..528c4afcb0 100644 --- a/sdk/go/kubernetes/discovery/v1/endpointSlice.go +++ b/sdk/go/kubernetes/discovery/v1/endpointSlice.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. @@ -138,6 +139,12 @@ func (i *EndpointSlice) ToEndpointSliceOutputWithContext(ctx context.Context) En return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceOutput) } +func (i *EndpointSlice) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlice] { + return pulumix.Output[*EndpointSlice]{ + OutputState: i.ToEndpointSliceOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceArrayInput is an input type that accepts EndpointSliceArray and EndpointSliceArrayOutput values. // You can construct a concrete instance of `EndpointSliceArrayInput` via: // @@ -163,6 +170,12 @@ func (i EndpointSliceArray) ToEndpointSliceArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceArrayOutput) } +func (i EndpointSliceArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlice] { + return pulumix.Output[[]*EndpointSlice]{ + OutputState: i.ToEndpointSliceArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceMapInput is an input type that accepts EndpointSliceMap and EndpointSliceMapOutput values. // You can construct a concrete instance of `EndpointSliceMapInput` via: // @@ -188,6 +201,12 @@ func (i EndpointSliceMap) ToEndpointSliceMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceMapOutput) } +func (i EndpointSliceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlice] { + return pulumix.Output[map[string]*EndpointSlice]{ + OutputState: i.ToEndpointSliceMapOutputWithContext(ctx).OutputState, + } +} + type EndpointSliceOutput struct{ *pulumi.OutputState } func (EndpointSliceOutput) ElementType() reflect.Type { @@ -202,6 +221,12 @@ func (o EndpointSliceOutput) ToEndpointSliceOutputWithContext(ctx context.Contex return o } +func (o EndpointSliceOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlice] { + return pulumix.Output[*EndpointSlice]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSliceOutput) AddressType() pulumi.StringOutput { return o.ApplyT(func(v *EndpointSlice) pulumi.StringOutput { return v.AddressType }).(pulumi.StringOutput) @@ -246,6 +271,12 @@ func (o EndpointSliceArrayOutput) ToEndpointSliceArrayOutputWithContext(ctx cont return o } +func (o EndpointSliceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlice] { + return pulumix.Output[[]*EndpointSlice]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceArrayOutput) Index(i pulumi.IntInput) EndpointSliceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointSlice { return vs[0].([]*EndpointSlice)[vs[1].(int)] @@ -266,6 +297,12 @@ func (o EndpointSliceMapOutput) ToEndpointSliceMapOutputWithContext(ctx context. return o } +func (o EndpointSliceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlice] { + return pulumix.Output[map[string]*EndpointSlice]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceMapOutput) MapIndex(k pulumi.StringInput) EndpointSliceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointSlice { return vs[0].(map[string]*EndpointSlice)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1/endpointSliceList.go b/sdk/go/kubernetes/discovery/v1/endpointSliceList.go index 7bbfc6fe0a..c77db8c5c2 100644 --- a/sdk/go/kubernetes/discovery/v1/endpointSliceList.go +++ b/sdk/go/kubernetes/discovery/v1/endpointSliceList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EndpointSliceList represents a list of endpoint slices @@ -117,6 +118,12 @@ func (i *EndpointSliceList) ToEndpointSliceListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListOutput) } +func (i *EndpointSliceList) ToOutput(ctx context.Context) pulumix.Output[*EndpointSliceList] { + return pulumix.Output[*EndpointSliceList]{ + OutputState: i.ToEndpointSliceListOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceListArrayInput is an input type that accepts EndpointSliceListArray and EndpointSliceListArrayOutput values. // You can construct a concrete instance of `EndpointSliceListArrayInput` via: // @@ -142,6 +149,12 @@ func (i EndpointSliceListArray) ToEndpointSliceListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListArrayOutput) } +func (i EndpointSliceListArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSliceList] { + return pulumix.Output[[]*EndpointSliceList]{ + OutputState: i.ToEndpointSliceListArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceListMapInput is an input type that accepts EndpointSliceListMap and EndpointSliceListMapOutput values. // You can construct a concrete instance of `EndpointSliceListMapInput` via: // @@ -167,6 +180,12 @@ func (i EndpointSliceListMap) ToEndpointSliceListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListMapOutput) } +func (i EndpointSliceListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSliceList] { + return pulumix.Output[map[string]*EndpointSliceList]{ + OutputState: i.ToEndpointSliceListMapOutputWithContext(ctx).OutputState, + } +} + type EndpointSliceListOutput struct{ *pulumi.OutputState } func (EndpointSliceListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o EndpointSliceListOutput) ToEndpointSliceListOutputWithContext(ctx contex return o } +func (o EndpointSliceListOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointSliceList] { + return pulumix.Output[*EndpointSliceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointSliceListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *EndpointSliceList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o EndpointSliceListArrayOutput) ToEndpointSliceListArrayOutputWithContext( return o } +func (o EndpointSliceListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSliceList] { + return pulumix.Output[[]*EndpointSliceList]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceListArrayOutput) Index(i pulumi.IntInput) EndpointSliceListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointSliceList { return vs[0].([]*EndpointSliceList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o EndpointSliceListMapOutput) ToEndpointSliceListMapOutputWithContext(ctx return o } +func (o EndpointSliceListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSliceList] { + return pulumix.Output[map[string]*EndpointSliceList]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceListMapOutput) MapIndex(k pulumi.StringInput) EndpointSliceListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointSliceList { return vs[0].(map[string]*EndpointSliceList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1/endpointSlicePatch.go b/sdk/go/kubernetes/discovery/v1/endpointSlicePatch.go index f273182887..dd5aa9cf7a 100644 --- a/sdk/go/kubernetes/discovery/v1/endpointSlicePatch.go +++ b/sdk/go/kubernetes/discovery/v1/endpointSlicePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -137,6 +138,12 @@ func (i *EndpointSlicePatch) ToEndpointSlicePatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchOutput) } +func (i *EndpointSlicePatch) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlicePatch] { + return pulumix.Output[*EndpointSlicePatch]{ + OutputState: i.ToEndpointSlicePatchOutputWithContext(ctx).OutputState, + } +} + // EndpointSlicePatchArrayInput is an input type that accepts EndpointSlicePatchArray and EndpointSlicePatchArrayOutput values. // You can construct a concrete instance of `EndpointSlicePatchArrayInput` via: // @@ -162,6 +169,12 @@ func (i EndpointSlicePatchArray) ToEndpointSlicePatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchArrayOutput) } +func (i EndpointSlicePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlicePatch] { + return pulumix.Output[[]*EndpointSlicePatch]{ + OutputState: i.ToEndpointSlicePatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSlicePatchMapInput is an input type that accepts EndpointSlicePatchMap and EndpointSlicePatchMapOutput values. // You can construct a concrete instance of `EndpointSlicePatchMapInput` via: // @@ -187,6 +200,12 @@ func (i EndpointSlicePatchMap) ToEndpointSlicePatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchMapOutput) } +func (i EndpointSlicePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlicePatch] { + return pulumix.Output[map[string]*EndpointSlicePatch]{ + OutputState: i.ToEndpointSlicePatchMapOutputWithContext(ctx).OutputState, + } +} + type EndpointSlicePatchOutput struct{ *pulumi.OutputState } func (EndpointSlicePatchOutput) ElementType() reflect.Type { @@ -201,6 +220,12 @@ func (o EndpointSlicePatchOutput) ToEndpointSlicePatchOutputWithContext(ctx cont return o } +func (o EndpointSlicePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlicePatch] { + return pulumix.Output[*EndpointSlicePatch]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSlicePatchOutput) AddressType() pulumi.StringPtrOutput { return o.ApplyT(func(v *EndpointSlicePatch) pulumi.StringPtrOutput { return v.AddressType }).(pulumi.StringPtrOutput) @@ -245,6 +270,12 @@ func (o EndpointSlicePatchArrayOutput) ToEndpointSlicePatchArrayOutputWithContex return o } +func (o EndpointSlicePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlicePatch] { + return pulumix.Output[[]*EndpointSlicePatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointSlicePatchArrayOutput) Index(i pulumi.IntInput) EndpointSlicePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointSlicePatch { return vs[0].([]*EndpointSlicePatch)[vs[1].(int)] @@ -265,6 +296,12 @@ func (o EndpointSlicePatchMapOutput) ToEndpointSlicePatchMapOutputWithContext(ct return o } +func (o EndpointSlicePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlicePatch] { + return pulumix.Output[map[string]*EndpointSlicePatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointSlicePatchMapOutput) MapIndex(k pulumi.StringInput) EndpointSlicePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointSlicePatch { return vs[0].(map[string]*EndpointSlicePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1/pulumiTypes.go b/sdk/go/kubernetes/discovery/v1/pulumiTypes.go index f36c297d05..01eed97beb 100644 --- a/sdk/go/kubernetes/discovery/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/discovery/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -78,6 +79,12 @@ func (i EndpointArgs) ToEndpointOutputWithContext(ctx context.Context) EndpointO return pulumi.ToOutputWithContext(ctx, i).(EndpointOutput) } +func (i EndpointArgs) ToOutput(ctx context.Context) pulumix.Output[Endpoint] { + return pulumix.Output[Endpoint]{ + OutputState: i.ToEndpointOutputWithContext(ctx).OutputState, + } +} + // EndpointArrayInput is an input type that accepts EndpointArray and EndpointArrayOutput values. // You can construct a concrete instance of `EndpointArrayInput` via: // @@ -103,6 +110,12 @@ func (i EndpointArray) ToEndpointArrayOutputWithContext(ctx context.Context) End return pulumi.ToOutputWithContext(ctx, i).(EndpointArrayOutput) } +func (i EndpointArray) ToOutput(ctx context.Context) pulumix.Output[[]Endpoint] { + return pulumix.Output[[]Endpoint]{ + OutputState: i.ToEndpointArrayOutputWithContext(ctx).OutputState, + } +} + // Endpoint represents a single logical "backend" implementing a service. type EndpointOutput struct{ *pulumi.OutputState } @@ -118,6 +131,12 @@ func (o EndpointOutput) ToEndpointOutputWithContext(ctx context.Context) Endpoin return o } +func (o EndpointOutput) ToOutput(ctx context.Context) pulumix.Output[Endpoint] { + return pulumix.Output[Endpoint]{ + OutputState: o.OutputState, + } +} + // addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. These are all assumed to be fungible and clients may choose to only use the first element. Refer to: https://issue.k8s.io/106267 func (o EndpointOutput) Addresses() pulumi.StringArrayOutput { return o.ApplyT(func(v Endpoint) []string { return v.Addresses }).(pulumi.StringArrayOutput) @@ -172,6 +191,12 @@ func (o EndpointArrayOutput) ToEndpointArrayOutputWithContext(ctx context.Contex return o } +func (o EndpointArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Endpoint] { + return pulumix.Output[[]Endpoint]{ + OutputState: o.OutputState, + } +} + func (o EndpointArrayOutput) Index(i pulumi.IntInput) EndpointOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Endpoint { return vs[0].([]Endpoint)[vs[1].(int)] @@ -221,6 +246,12 @@ func (i EndpointConditionsArgs) ToEndpointConditionsOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsOutput) } +func (i EndpointConditionsArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointConditions] { + return pulumix.Output[EndpointConditions]{ + OutputState: i.ToEndpointConditionsOutputWithContext(ctx).OutputState, + } +} + func (i EndpointConditionsArgs) ToEndpointConditionsPtrOutput() EndpointConditionsPtrOutput { return i.ToEndpointConditionsPtrOutputWithContext(context.Background()) } @@ -262,6 +293,12 @@ func (i *endpointConditionsPtrType) ToEndpointConditionsPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsPtrOutput) } +func (i *endpointConditionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditions] { + return pulumix.Output[*EndpointConditions]{ + OutputState: i.ToEndpointConditionsPtrOutputWithContext(ctx).OutputState, + } +} + // EndpointConditions represents the current condition of an endpoint. type EndpointConditionsOutput struct{ *pulumi.OutputState } @@ -287,6 +324,12 @@ func (o EndpointConditionsOutput) ToEndpointConditionsPtrOutputWithContext(ctx c }).(EndpointConditionsPtrOutput) } +func (o EndpointConditionsOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointConditions] { + return pulumix.Output[EndpointConditions]{ + OutputState: o.OutputState, + } +} + // ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. For compatibility reasons, ready should never be "true" for terminating endpoints, except when the normal readiness behavior is being explicitly overridden, for example when the associated Service has set the publishNotReadyAddresses flag. func (o EndpointConditionsOutput) Ready() pulumi.BoolPtrOutput { return o.ApplyT(func(v EndpointConditions) *bool { return v.Ready }).(pulumi.BoolPtrOutput) @@ -316,6 +359,12 @@ func (o EndpointConditionsPtrOutput) ToEndpointConditionsPtrOutputWithContext(ct return o } +func (o EndpointConditionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditions] { + return pulumix.Output[*EndpointConditions]{ + OutputState: o.OutputState, + } +} + func (o EndpointConditionsPtrOutput) Elem() EndpointConditionsOutput { return o.ApplyT(func(v *EndpointConditions) EndpointConditions { if v != nil { @@ -399,6 +448,12 @@ func (i EndpointConditionsPatchArgs) ToEndpointConditionsPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsPatchOutput) } +func (i EndpointConditionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointConditionsPatch] { + return pulumix.Output[EndpointConditionsPatch]{ + OutputState: i.ToEndpointConditionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i EndpointConditionsPatchArgs) ToEndpointConditionsPatchPtrOutput() EndpointConditionsPatchPtrOutput { return i.ToEndpointConditionsPatchPtrOutputWithContext(context.Background()) } @@ -440,6 +495,12 @@ func (i *endpointConditionsPatchPtrType) ToEndpointConditionsPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsPatchPtrOutput) } +func (i *endpointConditionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditionsPatch] { + return pulumix.Output[*EndpointConditionsPatch]{ + OutputState: i.ToEndpointConditionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // EndpointConditions represents the current condition of an endpoint. type EndpointConditionsPatchOutput struct{ *pulumi.OutputState } @@ -465,6 +526,12 @@ func (o EndpointConditionsPatchOutput) ToEndpointConditionsPatchPtrOutputWithCon }).(EndpointConditionsPatchPtrOutput) } +func (o EndpointConditionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointConditionsPatch] { + return pulumix.Output[EndpointConditionsPatch]{ + OutputState: o.OutputState, + } +} + // ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. For compatibility reasons, ready should never be "true" for terminating endpoints, except when the normal readiness behavior is being explicitly overridden, for example when the associated Service has set the publishNotReadyAddresses flag. func (o EndpointConditionsPatchOutput) Ready() pulumi.BoolPtrOutput { return o.ApplyT(func(v EndpointConditionsPatch) *bool { return v.Ready }).(pulumi.BoolPtrOutput) @@ -494,6 +561,12 @@ func (o EndpointConditionsPatchPtrOutput) ToEndpointConditionsPatchPtrOutputWith return o } +func (o EndpointConditionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditionsPatch] { + return pulumix.Output[*EndpointConditionsPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointConditionsPatchPtrOutput) Elem() EndpointConditionsPatchOutput { return o.ApplyT(func(v *EndpointConditionsPatch) EndpointConditionsPatch { if v != nil { @@ -569,6 +642,12 @@ func (i EndpointHintsArgs) ToEndpointHintsOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EndpointHintsOutput) } +func (i EndpointHintsArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointHints] { + return pulumix.Output[EndpointHints]{ + OutputState: i.ToEndpointHintsOutputWithContext(ctx).OutputState, + } +} + func (i EndpointHintsArgs) ToEndpointHintsPtrOutput() EndpointHintsPtrOutput { return i.ToEndpointHintsPtrOutputWithContext(context.Background()) } @@ -610,6 +689,12 @@ func (i *endpointHintsPtrType) ToEndpointHintsPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(EndpointHintsPtrOutput) } +func (i *endpointHintsPtrType) ToOutput(ctx context.Context) pulumix.Output[*EndpointHints] { + return pulumix.Output[*EndpointHints]{ + OutputState: i.ToEndpointHintsPtrOutputWithContext(ctx).OutputState, + } +} + // EndpointHints provides hints describing how an endpoint should be consumed. type EndpointHintsOutput struct{ *pulumi.OutputState } @@ -635,6 +720,12 @@ func (o EndpointHintsOutput) ToEndpointHintsPtrOutputWithContext(ctx context.Con }).(EndpointHintsPtrOutput) } +func (o EndpointHintsOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointHints] { + return pulumix.Output[EndpointHints]{ + OutputState: o.OutputState, + } +} + // forZones indicates the zone(s) this endpoint should be consumed by to enable topology aware routing. func (o EndpointHintsOutput) ForZones() ForZoneArrayOutput { return o.ApplyT(func(v EndpointHints) []ForZone { return v.ForZones }).(ForZoneArrayOutput) @@ -654,6 +745,12 @@ func (o EndpointHintsPtrOutput) ToEndpointHintsPtrOutputWithContext(ctx context. return o } +func (o EndpointHintsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointHints] { + return pulumix.Output[*EndpointHints]{ + OutputState: o.OutputState, + } +} + func (o EndpointHintsPtrOutput) Elem() EndpointHintsOutput { return o.ApplyT(func(v *EndpointHints) EndpointHints { if v != nil { @@ -709,6 +806,12 @@ func (i EndpointHintsPatchArgs) ToEndpointHintsPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointHintsPatchOutput) } +func (i EndpointHintsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointHintsPatch] { + return pulumix.Output[EndpointHintsPatch]{ + OutputState: i.ToEndpointHintsPatchOutputWithContext(ctx).OutputState, + } +} + func (i EndpointHintsPatchArgs) ToEndpointHintsPatchPtrOutput() EndpointHintsPatchPtrOutput { return i.ToEndpointHintsPatchPtrOutputWithContext(context.Background()) } @@ -750,6 +853,12 @@ func (i *endpointHintsPatchPtrType) ToEndpointHintsPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointHintsPatchPtrOutput) } +func (i *endpointHintsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EndpointHintsPatch] { + return pulumix.Output[*EndpointHintsPatch]{ + OutputState: i.ToEndpointHintsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // EndpointHints provides hints describing how an endpoint should be consumed. type EndpointHintsPatchOutput struct{ *pulumi.OutputState } @@ -775,6 +884,12 @@ func (o EndpointHintsPatchOutput) ToEndpointHintsPatchPtrOutputWithContext(ctx c }).(EndpointHintsPatchPtrOutput) } +func (o EndpointHintsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointHintsPatch] { + return pulumix.Output[EndpointHintsPatch]{ + OutputState: o.OutputState, + } +} + // forZones indicates the zone(s) this endpoint should be consumed by to enable topology aware routing. func (o EndpointHintsPatchOutput) ForZones() ForZonePatchArrayOutput { return o.ApplyT(func(v EndpointHintsPatch) []ForZonePatch { return v.ForZones }).(ForZonePatchArrayOutput) @@ -794,6 +909,12 @@ func (o EndpointHintsPatchPtrOutput) ToEndpointHintsPatchPtrOutputWithContext(ct return o } +func (o EndpointHintsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointHintsPatch] { + return pulumix.Output[*EndpointHintsPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointHintsPatchPtrOutput) Elem() EndpointHintsPatchOutput { return o.ApplyT(func(v *EndpointHintsPatch) EndpointHintsPatch { if v != nil { @@ -877,6 +998,12 @@ func (i EndpointPatchArgs) ToEndpointPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EndpointPatchOutput) } +func (i EndpointPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPatch] { + return pulumix.Output[EndpointPatch]{ + OutputState: i.ToEndpointPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointPatchArrayInput is an input type that accepts EndpointPatchArray and EndpointPatchArrayOutput values. // You can construct a concrete instance of `EndpointPatchArrayInput` via: // @@ -902,6 +1029,12 @@ func (i EndpointPatchArray) ToEndpointPatchArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EndpointPatchArrayOutput) } +func (i EndpointPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPatch] { + return pulumix.Output[[]EndpointPatch]{ + OutputState: i.ToEndpointPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Endpoint represents a single logical "backend" implementing a service. type EndpointPatchOutput struct{ *pulumi.OutputState } @@ -917,6 +1050,12 @@ func (o EndpointPatchOutput) ToEndpointPatchOutputWithContext(ctx context.Contex return o } +func (o EndpointPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPatch] { + return pulumix.Output[EndpointPatch]{ + OutputState: o.OutputState, + } +} + // addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. These are all assumed to be fungible and clients may choose to only use the first element. Refer to: https://issue.k8s.io/106267 func (o EndpointPatchOutput) Addresses() pulumi.StringArrayOutput { return o.ApplyT(func(v EndpointPatch) []string { return v.Addresses }).(pulumi.StringArrayOutput) @@ -971,6 +1110,12 @@ func (o EndpointPatchArrayOutput) ToEndpointPatchArrayOutputWithContext(ctx cont return o } +func (o EndpointPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPatch] { + return pulumix.Output[[]EndpointPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointPatchArrayOutput) Index(i pulumi.IntInput) EndpointPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPatch { return vs[0].([]EndpointPatch)[vs[1].(int)] @@ -1042,6 +1187,12 @@ func (i EndpointPortArgs) ToEndpointPortOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EndpointPortOutput) } +func (i EndpointPortArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPort] { + return pulumix.Output[EndpointPort]{ + OutputState: i.ToEndpointPortOutputWithContext(ctx).OutputState, + } +} + // EndpointPortArrayInput is an input type that accepts EndpointPortArray and EndpointPortArrayOutput values. // You can construct a concrete instance of `EndpointPortArrayInput` via: // @@ -1067,6 +1218,12 @@ func (i EndpointPortArray) ToEndpointPortArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(EndpointPortArrayOutput) } +func (i EndpointPortArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPort] { + return pulumix.Output[[]EndpointPort]{ + OutputState: i.ToEndpointPortArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointPort represents a Port used by an EndpointSlice type EndpointPortOutput struct{ *pulumi.OutputState } @@ -1082,6 +1239,12 @@ func (o EndpointPortOutput) ToEndpointPortOutputWithContext(ctx context.Context) return o } +func (o EndpointPortOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPort] { + return pulumix.Output[EndpointPort]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either: // // * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). @@ -1125,6 +1288,12 @@ func (o EndpointPortArrayOutput) ToEndpointPortArrayOutputWithContext(ctx contex return o } +func (o EndpointPortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPort] { + return pulumix.Output[[]EndpointPort]{ + OutputState: o.OutputState, + } +} + func (o EndpointPortArrayOutput) Index(i pulumi.IntInput) EndpointPortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPort { return vs[0].([]EndpointPort)[vs[1].(int)] @@ -1196,6 +1365,12 @@ func (i EndpointPortPatchArgs) ToEndpointPortPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointPortPatchOutput) } +func (i EndpointPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPortPatch] { + return pulumix.Output[EndpointPortPatch]{ + OutputState: i.ToEndpointPortPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointPortPatchArrayInput is an input type that accepts EndpointPortPatchArray and EndpointPortPatchArrayOutput values. // You can construct a concrete instance of `EndpointPortPatchArrayInput` via: // @@ -1221,6 +1396,12 @@ func (i EndpointPortPatchArray) ToEndpointPortPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointPortPatchArrayOutput) } +func (i EndpointPortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPortPatch] { + return pulumix.Output[[]EndpointPortPatch]{ + OutputState: i.ToEndpointPortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointPort represents a Port used by an EndpointSlice type EndpointPortPatchOutput struct{ *pulumi.OutputState } @@ -1236,6 +1417,12 @@ func (o EndpointPortPatchOutput) ToEndpointPortPatchOutputWithContext(ctx contex return o } +func (o EndpointPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPortPatch] { + return pulumix.Output[EndpointPortPatch]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either: // // * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). @@ -1279,6 +1466,12 @@ func (o EndpointPortPatchArrayOutput) ToEndpointPortPatchArrayOutputWithContext( return o } +func (o EndpointPortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPortPatch] { + return pulumix.Output[[]EndpointPortPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointPortPatchArrayOutput) Index(i pulumi.IntInput) EndpointPortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPortPatch { return vs[0].([]EndpointPortPatch)[vs[1].(int)] @@ -1340,6 +1533,12 @@ func (i EndpointSliceTypeArgs) ToEndpointSliceTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceTypeOutput) } +func (i EndpointSliceTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceType] { + return pulumix.Output[EndpointSliceType]{ + OutputState: i.ToEndpointSliceTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceTypeArrayInput is an input type that accepts EndpointSliceTypeArray and EndpointSliceTypeArrayOutput values. // You can construct a concrete instance of `EndpointSliceTypeArrayInput` via: // @@ -1365,6 +1564,12 @@ func (i EndpointSliceTypeArray) ToEndpointSliceTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceTypeArrayOutput) } +func (i EndpointSliceTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSliceType] { + return pulumix.Output[[]EndpointSliceType]{ + OutputState: i.ToEndpointSliceTypeArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. type EndpointSliceTypeOutput struct{ *pulumi.OutputState } @@ -1380,6 +1585,12 @@ func (o EndpointSliceTypeOutput) ToEndpointSliceTypeOutputWithContext(ctx contex return o } +func (o EndpointSliceTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceType] { + return pulumix.Output[EndpointSliceType]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSliceTypeOutput) AddressType() pulumi.StringOutput { return o.ApplyT(func(v EndpointSliceType) string { return v.AddressType }).(pulumi.StringOutput) @@ -1424,6 +1635,12 @@ func (o EndpointSliceTypeArrayOutput) ToEndpointSliceTypeArrayOutputWithContext( return o } +func (o EndpointSliceTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSliceType] { + return pulumix.Output[[]EndpointSliceType]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceTypeArrayOutput) Index(i pulumi.IntInput) EndpointSliceTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointSliceType { return vs[0].([]EndpointSliceType)[vs[1].(int)] @@ -1477,6 +1694,12 @@ func (i EndpointSliceListTypeArgs) ToEndpointSliceListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListTypeOutput) } +func (i EndpointSliceListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceListType] { + return pulumix.Output[EndpointSliceListType]{ + OutputState: i.ToEndpointSliceListTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceList represents a list of endpoint slices type EndpointSliceListTypeOutput struct{ *pulumi.OutputState } @@ -1492,6 +1715,12 @@ func (o EndpointSliceListTypeOutput) ToEndpointSliceListTypeOutputWithContext(ct return o } +func (o EndpointSliceListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceListType] { + return pulumix.Output[EndpointSliceListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointSliceListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointSliceListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1567,6 +1796,12 @@ func (i EndpointSlicePatchTypeArgs) ToEndpointSlicePatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchTypeOutput) } +func (i EndpointSlicePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSlicePatchType] { + return pulumix.Output[EndpointSlicePatchType]{ + OutputState: i.ToEndpointSlicePatchTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. type EndpointSlicePatchTypeOutput struct{ *pulumi.OutputState } @@ -1582,6 +1817,12 @@ func (o EndpointSlicePatchTypeOutput) ToEndpointSlicePatchTypeOutputWithContext( return o } +func (o EndpointSlicePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSlicePatchType] { + return pulumix.Output[EndpointSlicePatchType]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSlicePatchTypeOutput) AddressType() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointSlicePatchType) *string { return v.AddressType }).(pulumi.StringPtrOutput) @@ -1647,6 +1888,12 @@ func (i ForZoneArgs) ToForZoneOutputWithContext(ctx context.Context) ForZoneOutp return pulumi.ToOutputWithContext(ctx, i).(ForZoneOutput) } +func (i ForZoneArgs) ToOutput(ctx context.Context) pulumix.Output[ForZone] { + return pulumix.Output[ForZone]{ + OutputState: i.ToForZoneOutputWithContext(ctx).OutputState, + } +} + // ForZoneArrayInput is an input type that accepts ForZoneArray and ForZoneArrayOutput values. // You can construct a concrete instance of `ForZoneArrayInput` via: // @@ -1672,6 +1919,12 @@ func (i ForZoneArray) ToForZoneArrayOutputWithContext(ctx context.Context) ForZo return pulumi.ToOutputWithContext(ctx, i).(ForZoneArrayOutput) } +func (i ForZoneArray) ToOutput(ctx context.Context) pulumix.Output[[]ForZone] { + return pulumix.Output[[]ForZone]{ + OutputState: i.ToForZoneArrayOutputWithContext(ctx).OutputState, + } +} + // ForZone provides information about which zones should consume this endpoint. type ForZoneOutput struct{ *pulumi.OutputState } @@ -1687,6 +1940,12 @@ func (o ForZoneOutput) ToForZoneOutputWithContext(ctx context.Context) ForZoneOu return o } +func (o ForZoneOutput) ToOutput(ctx context.Context) pulumix.Output[ForZone] { + return pulumix.Output[ForZone]{ + OutputState: o.OutputState, + } +} + // name represents the name of the zone. func (o ForZoneOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ForZone) string { return v.Name }).(pulumi.StringOutput) @@ -1706,6 +1965,12 @@ func (o ForZoneArrayOutput) ToForZoneArrayOutputWithContext(ctx context.Context) return o } +func (o ForZoneArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ForZone] { + return pulumix.Output[[]ForZone]{ + OutputState: o.OutputState, + } +} + func (o ForZoneArrayOutput) Index(i pulumi.IntInput) ForZoneOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ForZone { return vs[0].([]ForZone)[vs[1].(int)] @@ -1747,6 +2012,12 @@ func (i ForZonePatchArgs) ToForZonePatchOutputWithContext(ctx context.Context) F return pulumi.ToOutputWithContext(ctx, i).(ForZonePatchOutput) } +func (i ForZonePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ForZonePatch] { + return pulumix.Output[ForZonePatch]{ + OutputState: i.ToForZonePatchOutputWithContext(ctx).OutputState, + } +} + // ForZonePatchArrayInput is an input type that accepts ForZonePatchArray and ForZonePatchArrayOutput values. // You can construct a concrete instance of `ForZonePatchArrayInput` via: // @@ -1772,6 +2043,12 @@ func (i ForZonePatchArray) ToForZonePatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ForZonePatchArrayOutput) } +func (i ForZonePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ForZonePatch] { + return pulumix.Output[[]ForZonePatch]{ + OutputState: i.ToForZonePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ForZone provides information about which zones should consume this endpoint. type ForZonePatchOutput struct{ *pulumi.OutputState } @@ -1787,6 +2064,12 @@ func (o ForZonePatchOutput) ToForZonePatchOutputWithContext(ctx context.Context) return o } +func (o ForZonePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ForZonePatch] { + return pulumix.Output[ForZonePatch]{ + OutputState: o.OutputState, + } +} + // name represents the name of the zone. func (o ForZonePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ForZonePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1806,6 +2089,12 @@ func (o ForZonePatchArrayOutput) ToForZonePatchArrayOutputWithContext(ctx contex return o } +func (o ForZonePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ForZonePatch] { + return pulumix.Output[[]ForZonePatch]{ + OutputState: o.OutputState, + } +} + func (o ForZonePatchArrayOutput) Index(i pulumi.IntInput) ForZonePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ForZonePatch { return vs[0].([]ForZonePatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/discovery/v1beta1/endpointSlice.go b/sdk/go/kubernetes/discovery/v1beta1/endpointSlice.go index 4c2edf9b22..6b876ce502 100644 --- a/sdk/go/kubernetes/discovery/v1beta1/endpointSlice.go +++ b/sdk/go/kubernetes/discovery/v1beta1/endpointSlice.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. @@ -138,6 +139,12 @@ func (i *EndpointSlice) ToEndpointSliceOutputWithContext(ctx context.Context) En return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceOutput) } +func (i *EndpointSlice) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlice] { + return pulumix.Output[*EndpointSlice]{ + OutputState: i.ToEndpointSliceOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceArrayInput is an input type that accepts EndpointSliceArray and EndpointSliceArrayOutput values. // You can construct a concrete instance of `EndpointSliceArrayInput` via: // @@ -163,6 +170,12 @@ func (i EndpointSliceArray) ToEndpointSliceArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceArrayOutput) } +func (i EndpointSliceArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlice] { + return pulumix.Output[[]*EndpointSlice]{ + OutputState: i.ToEndpointSliceArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceMapInput is an input type that accepts EndpointSliceMap and EndpointSliceMapOutput values. // You can construct a concrete instance of `EndpointSliceMapInput` via: // @@ -188,6 +201,12 @@ func (i EndpointSliceMap) ToEndpointSliceMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceMapOutput) } +func (i EndpointSliceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlice] { + return pulumix.Output[map[string]*EndpointSlice]{ + OutputState: i.ToEndpointSliceMapOutputWithContext(ctx).OutputState, + } +} + type EndpointSliceOutput struct{ *pulumi.OutputState } func (EndpointSliceOutput) ElementType() reflect.Type { @@ -202,6 +221,12 @@ func (o EndpointSliceOutput) ToEndpointSliceOutputWithContext(ctx context.Contex return o } +func (o EndpointSliceOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlice] { + return pulumix.Output[*EndpointSlice]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSliceOutput) AddressType() pulumi.StringOutput { return o.ApplyT(func(v *EndpointSlice) pulumi.StringOutput { return v.AddressType }).(pulumi.StringOutput) @@ -246,6 +271,12 @@ func (o EndpointSliceArrayOutput) ToEndpointSliceArrayOutputWithContext(ctx cont return o } +func (o EndpointSliceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlice] { + return pulumix.Output[[]*EndpointSlice]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceArrayOutput) Index(i pulumi.IntInput) EndpointSliceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointSlice { return vs[0].([]*EndpointSlice)[vs[1].(int)] @@ -266,6 +297,12 @@ func (o EndpointSliceMapOutput) ToEndpointSliceMapOutputWithContext(ctx context. return o } +func (o EndpointSliceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlice] { + return pulumix.Output[map[string]*EndpointSlice]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceMapOutput) MapIndex(k pulumi.StringInput) EndpointSliceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointSlice { return vs[0].(map[string]*EndpointSlice)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1beta1/endpointSliceList.go b/sdk/go/kubernetes/discovery/v1beta1/endpointSliceList.go index 9d84926e1b..9810db37fe 100644 --- a/sdk/go/kubernetes/discovery/v1beta1/endpointSliceList.go +++ b/sdk/go/kubernetes/discovery/v1beta1/endpointSliceList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EndpointSliceList represents a list of endpoint slices @@ -117,6 +118,12 @@ func (i *EndpointSliceList) ToEndpointSliceListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListOutput) } +func (i *EndpointSliceList) ToOutput(ctx context.Context) pulumix.Output[*EndpointSliceList] { + return pulumix.Output[*EndpointSliceList]{ + OutputState: i.ToEndpointSliceListOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceListArrayInput is an input type that accepts EndpointSliceListArray and EndpointSliceListArrayOutput values. // You can construct a concrete instance of `EndpointSliceListArrayInput` via: // @@ -142,6 +149,12 @@ func (i EndpointSliceListArray) ToEndpointSliceListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListArrayOutput) } +func (i EndpointSliceListArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSliceList] { + return pulumix.Output[[]*EndpointSliceList]{ + OutputState: i.ToEndpointSliceListArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceListMapInput is an input type that accepts EndpointSliceListMap and EndpointSliceListMapOutput values. // You can construct a concrete instance of `EndpointSliceListMapInput` via: // @@ -167,6 +180,12 @@ func (i EndpointSliceListMap) ToEndpointSliceListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListMapOutput) } +func (i EndpointSliceListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSliceList] { + return pulumix.Output[map[string]*EndpointSliceList]{ + OutputState: i.ToEndpointSliceListMapOutputWithContext(ctx).OutputState, + } +} + type EndpointSliceListOutput struct{ *pulumi.OutputState } func (EndpointSliceListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o EndpointSliceListOutput) ToEndpointSliceListOutputWithContext(ctx contex return o } +func (o EndpointSliceListOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointSliceList] { + return pulumix.Output[*EndpointSliceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointSliceListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *EndpointSliceList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o EndpointSliceListArrayOutput) ToEndpointSliceListArrayOutputWithContext( return o } +func (o EndpointSliceListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSliceList] { + return pulumix.Output[[]*EndpointSliceList]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceListArrayOutput) Index(i pulumi.IntInput) EndpointSliceListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointSliceList { return vs[0].([]*EndpointSliceList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o EndpointSliceListMapOutput) ToEndpointSliceListMapOutputWithContext(ctx return o } +func (o EndpointSliceListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSliceList] { + return pulumix.Output[map[string]*EndpointSliceList]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceListMapOutput) MapIndex(k pulumi.StringInput) EndpointSliceListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointSliceList { return vs[0].(map[string]*EndpointSliceList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1beta1/endpointSlicePatch.go b/sdk/go/kubernetes/discovery/v1beta1/endpointSlicePatch.go index cd4cb666bd..e2ffe4cbfe 100644 --- a/sdk/go/kubernetes/discovery/v1beta1/endpointSlicePatch.go +++ b/sdk/go/kubernetes/discovery/v1beta1/endpointSlicePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -137,6 +138,12 @@ func (i *EndpointSlicePatch) ToEndpointSlicePatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchOutput) } +func (i *EndpointSlicePatch) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlicePatch] { + return pulumix.Output[*EndpointSlicePatch]{ + OutputState: i.ToEndpointSlicePatchOutputWithContext(ctx).OutputState, + } +} + // EndpointSlicePatchArrayInput is an input type that accepts EndpointSlicePatchArray and EndpointSlicePatchArrayOutput values. // You can construct a concrete instance of `EndpointSlicePatchArrayInput` via: // @@ -162,6 +169,12 @@ func (i EndpointSlicePatchArray) ToEndpointSlicePatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchArrayOutput) } +func (i EndpointSlicePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlicePatch] { + return pulumix.Output[[]*EndpointSlicePatch]{ + OutputState: i.ToEndpointSlicePatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSlicePatchMapInput is an input type that accepts EndpointSlicePatchMap and EndpointSlicePatchMapOutput values. // You can construct a concrete instance of `EndpointSlicePatchMapInput` via: // @@ -187,6 +200,12 @@ func (i EndpointSlicePatchMap) ToEndpointSlicePatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchMapOutput) } +func (i EndpointSlicePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlicePatch] { + return pulumix.Output[map[string]*EndpointSlicePatch]{ + OutputState: i.ToEndpointSlicePatchMapOutputWithContext(ctx).OutputState, + } +} + type EndpointSlicePatchOutput struct{ *pulumi.OutputState } func (EndpointSlicePatchOutput) ElementType() reflect.Type { @@ -201,6 +220,12 @@ func (o EndpointSlicePatchOutput) ToEndpointSlicePatchOutputWithContext(ctx cont return o } +func (o EndpointSlicePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointSlicePatch] { + return pulumix.Output[*EndpointSlicePatch]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSlicePatchOutput) AddressType() pulumi.StringPtrOutput { return o.ApplyT(func(v *EndpointSlicePatch) pulumi.StringPtrOutput { return v.AddressType }).(pulumi.StringPtrOutput) @@ -245,6 +270,12 @@ func (o EndpointSlicePatchArrayOutput) ToEndpointSlicePatchArrayOutputWithContex return o } +func (o EndpointSlicePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EndpointSlicePatch] { + return pulumix.Output[[]*EndpointSlicePatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointSlicePatchArrayOutput) Index(i pulumi.IntInput) EndpointSlicePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EndpointSlicePatch { return vs[0].([]*EndpointSlicePatch)[vs[1].(int)] @@ -265,6 +296,12 @@ func (o EndpointSlicePatchMapOutput) ToEndpointSlicePatchMapOutputWithContext(ct return o } +func (o EndpointSlicePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EndpointSlicePatch] { + return pulumix.Output[map[string]*EndpointSlicePatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointSlicePatchMapOutput) MapIndex(k pulumi.StringInput) EndpointSlicePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EndpointSlicePatch { return vs[0].(map[string]*EndpointSlicePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/discovery/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/discovery/v1beta1/pulumiTypes.go index 787df73d1c..301894acbc 100644 --- a/sdk/go/kubernetes/discovery/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/discovery/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -82,6 +83,12 @@ func (i EndpointArgs) ToEndpointOutputWithContext(ctx context.Context) EndpointO return pulumi.ToOutputWithContext(ctx, i).(EndpointOutput) } +func (i EndpointArgs) ToOutput(ctx context.Context) pulumix.Output[Endpoint] { + return pulumix.Output[Endpoint]{ + OutputState: i.ToEndpointOutputWithContext(ctx).OutputState, + } +} + // EndpointArrayInput is an input type that accepts EndpointArray and EndpointArrayOutput values. // You can construct a concrete instance of `EndpointArrayInput` via: // @@ -107,6 +114,12 @@ func (i EndpointArray) ToEndpointArrayOutputWithContext(ctx context.Context) End return pulumi.ToOutputWithContext(ctx, i).(EndpointArrayOutput) } +func (i EndpointArray) ToOutput(ctx context.Context) pulumix.Output[[]Endpoint] { + return pulumix.Output[[]Endpoint]{ + OutputState: i.ToEndpointArrayOutputWithContext(ctx).OutputState, + } +} + // Endpoint represents a single logical "backend" implementing a service. type EndpointOutput struct{ *pulumi.OutputState } @@ -122,6 +135,12 @@ func (o EndpointOutput) ToEndpointOutputWithContext(ctx context.Context) Endpoin return o } +func (o EndpointOutput) ToOutput(ctx context.Context) pulumix.Output[Endpoint] { + return pulumix.Output[Endpoint]{ + OutputState: o.OutputState, + } +} + // addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. func (o EndpointOutput) Addresses() pulumi.StringArrayOutput { return o.ApplyT(func(v Endpoint) []string { return v.Addresses }).(pulumi.StringArrayOutput) @@ -173,6 +192,12 @@ func (o EndpointArrayOutput) ToEndpointArrayOutputWithContext(ctx context.Contex return o } +func (o EndpointArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Endpoint] { + return pulumix.Output[[]Endpoint]{ + OutputState: o.OutputState, + } +} + func (o EndpointArrayOutput) Index(i pulumi.IntInput) EndpointOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Endpoint { return vs[0].([]Endpoint)[vs[1].(int)] @@ -222,6 +247,12 @@ func (i EndpointConditionsArgs) ToEndpointConditionsOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsOutput) } +func (i EndpointConditionsArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointConditions] { + return pulumix.Output[EndpointConditions]{ + OutputState: i.ToEndpointConditionsOutputWithContext(ctx).OutputState, + } +} + func (i EndpointConditionsArgs) ToEndpointConditionsPtrOutput() EndpointConditionsPtrOutput { return i.ToEndpointConditionsPtrOutputWithContext(context.Background()) } @@ -263,6 +294,12 @@ func (i *endpointConditionsPtrType) ToEndpointConditionsPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsPtrOutput) } +func (i *endpointConditionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditions] { + return pulumix.Output[*EndpointConditions]{ + OutputState: i.ToEndpointConditionsPtrOutputWithContext(ctx).OutputState, + } +} + // EndpointConditions represents the current condition of an endpoint. type EndpointConditionsOutput struct{ *pulumi.OutputState } @@ -288,6 +325,12 @@ func (o EndpointConditionsOutput) ToEndpointConditionsPtrOutputWithContext(ctx c }).(EndpointConditionsPtrOutput) } +func (o EndpointConditionsOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointConditions] { + return pulumix.Output[EndpointConditions]{ + OutputState: o.OutputState, + } +} + // ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. func (o EndpointConditionsOutput) Ready() pulumi.BoolPtrOutput { return o.ApplyT(func(v EndpointConditions) *bool { return v.Ready }).(pulumi.BoolPtrOutput) @@ -317,6 +360,12 @@ func (o EndpointConditionsPtrOutput) ToEndpointConditionsPtrOutputWithContext(ct return o } +func (o EndpointConditionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditions] { + return pulumix.Output[*EndpointConditions]{ + OutputState: o.OutputState, + } +} + func (o EndpointConditionsPtrOutput) Elem() EndpointConditionsOutput { return o.ApplyT(func(v *EndpointConditions) EndpointConditions { if v != nil { @@ -400,6 +449,12 @@ func (i EndpointConditionsPatchArgs) ToEndpointConditionsPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsPatchOutput) } +func (i EndpointConditionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointConditionsPatch] { + return pulumix.Output[EndpointConditionsPatch]{ + OutputState: i.ToEndpointConditionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i EndpointConditionsPatchArgs) ToEndpointConditionsPatchPtrOutput() EndpointConditionsPatchPtrOutput { return i.ToEndpointConditionsPatchPtrOutputWithContext(context.Background()) } @@ -441,6 +496,12 @@ func (i *endpointConditionsPatchPtrType) ToEndpointConditionsPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(EndpointConditionsPatchPtrOutput) } +func (i *endpointConditionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditionsPatch] { + return pulumix.Output[*EndpointConditionsPatch]{ + OutputState: i.ToEndpointConditionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // EndpointConditions represents the current condition of an endpoint. type EndpointConditionsPatchOutput struct{ *pulumi.OutputState } @@ -466,6 +527,12 @@ func (o EndpointConditionsPatchOutput) ToEndpointConditionsPatchPtrOutputWithCon }).(EndpointConditionsPatchPtrOutput) } +func (o EndpointConditionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointConditionsPatch] { + return pulumix.Output[EndpointConditionsPatch]{ + OutputState: o.OutputState, + } +} + // ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. func (o EndpointConditionsPatchOutput) Ready() pulumi.BoolPtrOutput { return o.ApplyT(func(v EndpointConditionsPatch) *bool { return v.Ready }).(pulumi.BoolPtrOutput) @@ -495,6 +562,12 @@ func (o EndpointConditionsPatchPtrOutput) ToEndpointConditionsPatchPtrOutputWith return o } +func (o EndpointConditionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EndpointConditionsPatch] { + return pulumix.Output[*EndpointConditionsPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointConditionsPatchPtrOutput) Elem() EndpointConditionsPatchOutput { return o.ApplyT(func(v *EndpointConditionsPatch) EndpointConditionsPatch { if v != nil { @@ -602,6 +675,12 @@ func (i EndpointPatchArgs) ToEndpointPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EndpointPatchOutput) } +func (i EndpointPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPatch] { + return pulumix.Output[EndpointPatch]{ + OutputState: i.ToEndpointPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointPatchArrayInput is an input type that accepts EndpointPatchArray and EndpointPatchArrayOutput values. // You can construct a concrete instance of `EndpointPatchArrayInput` via: // @@ -627,6 +706,12 @@ func (i EndpointPatchArray) ToEndpointPatchArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EndpointPatchArrayOutput) } +func (i EndpointPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPatch] { + return pulumix.Output[[]EndpointPatch]{ + OutputState: i.ToEndpointPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Endpoint represents a single logical "backend" implementing a service. type EndpointPatchOutput struct{ *pulumi.OutputState } @@ -642,6 +727,12 @@ func (o EndpointPatchOutput) ToEndpointPatchOutputWithContext(ctx context.Contex return o } +func (o EndpointPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPatch] { + return pulumix.Output[EndpointPatch]{ + OutputState: o.OutputState, + } +} + // addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. func (o EndpointPatchOutput) Addresses() pulumi.StringArrayOutput { return o.ApplyT(func(v EndpointPatch) []string { return v.Addresses }).(pulumi.StringArrayOutput) @@ -693,6 +784,12 @@ func (o EndpointPatchArrayOutput) ToEndpointPatchArrayOutputWithContext(ctx cont return o } +func (o EndpointPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPatch] { + return pulumix.Output[[]EndpointPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointPatchArrayOutput) Index(i pulumi.IntInput) EndpointPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPatch { return vs[0].([]EndpointPatch)[vs[1].(int)] @@ -746,6 +843,12 @@ func (i EndpointPortArgs) ToEndpointPortOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EndpointPortOutput) } +func (i EndpointPortArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPort] { + return pulumix.Output[EndpointPort]{ + OutputState: i.ToEndpointPortOutputWithContext(ctx).OutputState, + } +} + // EndpointPortArrayInput is an input type that accepts EndpointPortArray and EndpointPortArrayOutput values. // You can construct a concrete instance of `EndpointPortArrayInput` via: // @@ -771,6 +874,12 @@ func (i EndpointPortArray) ToEndpointPortArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(EndpointPortArrayOutput) } +func (i EndpointPortArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPort] { + return pulumix.Output[[]EndpointPort]{ + OutputState: i.ToEndpointPortArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointPort represents a Port used by an EndpointSlice type EndpointPortOutput struct{ *pulumi.OutputState } @@ -786,6 +895,12 @@ func (o EndpointPortOutput) ToEndpointPortOutputWithContext(ctx context.Context) return o } +func (o EndpointPortOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPort] { + return pulumix.Output[EndpointPort]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This field follows standard Kubernetes label syntax. Un-prefixed names are reserved for IANA standard service names (as per RFC-6335 and http://www.iana.org/assignments/service-names). Non-standard protocols should use prefixed names. Default is empty string. func (o EndpointPortOutput) AppProtocol() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointPort) *string { return v.AppProtocol }).(pulumi.StringPtrOutput) @@ -820,6 +935,12 @@ func (o EndpointPortArrayOutput) ToEndpointPortArrayOutputWithContext(ctx contex return o } +func (o EndpointPortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPort] { + return pulumix.Output[[]EndpointPort]{ + OutputState: o.OutputState, + } +} + func (o EndpointPortArrayOutput) Index(i pulumi.IntInput) EndpointPortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPort { return vs[0].([]EndpointPort)[vs[1].(int)] @@ -873,6 +994,12 @@ func (i EndpointPortPatchArgs) ToEndpointPortPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointPortPatchOutput) } +func (i EndpointPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointPortPatch] { + return pulumix.Output[EndpointPortPatch]{ + OutputState: i.ToEndpointPortPatchOutputWithContext(ctx).OutputState, + } +} + // EndpointPortPatchArrayInput is an input type that accepts EndpointPortPatchArray and EndpointPortPatchArrayOutput values. // You can construct a concrete instance of `EndpointPortPatchArrayInput` via: // @@ -898,6 +1025,12 @@ func (i EndpointPortPatchArray) ToEndpointPortPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointPortPatchArrayOutput) } +func (i EndpointPortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPortPatch] { + return pulumix.Output[[]EndpointPortPatch]{ + OutputState: i.ToEndpointPortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointPort represents a Port used by an EndpointSlice type EndpointPortPatchOutput struct{ *pulumi.OutputState } @@ -913,6 +1046,12 @@ func (o EndpointPortPatchOutput) ToEndpointPortPatchOutputWithContext(ctx contex return o } +func (o EndpointPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointPortPatch] { + return pulumix.Output[EndpointPortPatch]{ + OutputState: o.OutputState, + } +} + // The application protocol for this port. This field follows standard Kubernetes label syntax. Un-prefixed names are reserved for IANA standard service names (as per RFC-6335 and http://www.iana.org/assignments/service-names). Non-standard protocols should use prefixed names. Default is empty string. func (o EndpointPortPatchOutput) AppProtocol() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointPortPatch) *string { return v.AppProtocol }).(pulumi.StringPtrOutput) @@ -947,6 +1086,12 @@ func (o EndpointPortPatchArrayOutput) ToEndpointPortPatchArrayOutputWithContext( return o } +func (o EndpointPortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointPortPatch] { + return pulumix.Output[[]EndpointPortPatch]{ + OutputState: o.OutputState, + } +} + func (o EndpointPortPatchArrayOutput) Index(i pulumi.IntInput) EndpointPortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointPortPatch { return vs[0].([]EndpointPortPatch)[vs[1].(int)] @@ -1008,6 +1153,12 @@ func (i EndpointSliceTypeArgs) ToEndpointSliceTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceTypeOutput) } +func (i EndpointSliceTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceType] { + return pulumix.Output[EndpointSliceType]{ + OutputState: i.ToEndpointSliceTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceTypeArrayInput is an input type that accepts EndpointSliceTypeArray and EndpointSliceTypeArrayOutput values. // You can construct a concrete instance of `EndpointSliceTypeArrayInput` via: // @@ -1033,6 +1184,12 @@ func (i EndpointSliceTypeArray) ToEndpointSliceTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceTypeArrayOutput) } +func (i EndpointSliceTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSliceType] { + return pulumix.Output[[]EndpointSliceType]{ + OutputState: i.ToEndpointSliceTypeArrayOutputWithContext(ctx).OutputState, + } +} + // EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. type EndpointSliceTypeOutput struct{ *pulumi.OutputState } @@ -1048,6 +1205,12 @@ func (o EndpointSliceTypeOutput) ToEndpointSliceTypeOutputWithContext(ctx contex return o } +func (o EndpointSliceTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceType] { + return pulumix.Output[EndpointSliceType]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSliceTypeOutput) AddressType() pulumi.StringOutput { return o.ApplyT(func(v EndpointSliceType) string { return v.AddressType }).(pulumi.StringOutput) @@ -1092,6 +1255,12 @@ func (o EndpointSliceTypeArrayOutput) ToEndpointSliceTypeArrayOutputWithContext( return o } +func (o EndpointSliceTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EndpointSliceType] { + return pulumix.Output[[]EndpointSliceType]{ + OutputState: o.OutputState, + } +} + func (o EndpointSliceTypeArrayOutput) Index(i pulumi.IntInput) EndpointSliceTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EndpointSliceType { return vs[0].([]EndpointSliceType)[vs[1].(int)] @@ -1145,6 +1314,12 @@ func (i EndpointSliceListTypeArgs) ToEndpointSliceListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(EndpointSliceListTypeOutput) } +func (i EndpointSliceListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceListType] { + return pulumix.Output[EndpointSliceListType]{ + OutputState: i.ToEndpointSliceListTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointSliceList represents a list of endpoint slices type EndpointSliceListTypeOutput struct{ *pulumi.OutputState } @@ -1160,6 +1335,12 @@ func (o EndpointSliceListTypeOutput) ToEndpointSliceListTypeOutputWithContext(ct return o } +func (o EndpointSliceListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSliceListType] { + return pulumix.Output[EndpointSliceListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EndpointSliceListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointSliceListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1235,6 +1416,12 @@ func (i EndpointSlicePatchTypeArgs) ToEndpointSlicePatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(EndpointSlicePatchTypeOutput) } +func (i EndpointSlicePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EndpointSlicePatchType] { + return pulumix.Output[EndpointSlicePatchType]{ + OutputState: i.ToEndpointSlicePatchTypeOutputWithContext(ctx).OutputState, + } +} + // EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. type EndpointSlicePatchTypeOutput struct{ *pulumi.OutputState } @@ -1250,6 +1437,12 @@ func (o EndpointSlicePatchTypeOutput) ToEndpointSlicePatchTypeOutputWithContext( return o } +func (o EndpointSlicePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EndpointSlicePatchType] { + return pulumix.Output[EndpointSlicePatchType]{ + OutputState: o.OutputState, + } +} + // addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. func (o EndpointSlicePatchTypeOutput) AddressType() pulumi.StringPtrOutput { return o.ApplyT(func(v EndpointSlicePatchType) *string { return v.AddressType }).(pulumi.StringPtrOutput) diff --git a/sdk/go/kubernetes/events/v1/event.go b/sdk/go/kubernetes/events/v1/event.go index 6afbeef85a..3c6a278e46 100644 --- a/sdk/go/kubernetes/events/v1/event.go +++ b/sdk/go/kubernetes/events/v1/event.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. @@ -205,6 +206,12 @@ func (i *Event) ToEventOutputWithContext(ctx context.Context) EventOutput { return pulumi.ToOutputWithContext(ctx, i).(EventOutput) } +func (i *Event) ToOutput(ctx context.Context) pulumix.Output[*Event] { + return pulumix.Output[*Event]{ + OutputState: i.ToEventOutputWithContext(ctx).OutputState, + } +} + // EventArrayInput is an input type that accepts EventArray and EventArrayOutput values. // You can construct a concrete instance of `EventArrayInput` via: // @@ -230,6 +237,12 @@ func (i EventArray) ToEventArrayOutputWithContext(ctx context.Context) EventArra return pulumi.ToOutputWithContext(ctx, i).(EventArrayOutput) } +func (i EventArray) ToOutput(ctx context.Context) pulumix.Output[[]*Event] { + return pulumix.Output[[]*Event]{ + OutputState: i.ToEventArrayOutputWithContext(ctx).OutputState, + } +} + // EventMapInput is an input type that accepts EventMap and EventMapOutput values. // You can construct a concrete instance of `EventMapInput` via: // @@ -255,6 +268,12 @@ func (i EventMap) ToEventMapOutputWithContext(ctx context.Context) EventMapOutpu return pulumi.ToOutputWithContext(ctx, i).(EventMapOutput) } +func (i EventMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Event] { + return pulumix.Output[map[string]*Event]{ + OutputState: i.ToEventMapOutputWithContext(ctx).OutputState, + } +} + type EventOutput struct{ *pulumi.OutputState } func (EventOutput) ElementType() reflect.Type { @@ -269,6 +288,12 @@ func (o EventOutput) ToEventOutputWithContext(ctx context.Context) EventOutput { return o } +func (o EventOutput) ToOutput(ctx context.Context) pulumix.Output[*Event] { + return pulumix.Output[*Event]{ + OutputState: o.OutputState, + } +} + // action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters. func (o EventOutput) Action() pulumi.StringOutput { return o.ApplyT(func(v *Event) pulumi.StringOutput { return v.Action }).(pulumi.StringOutput) @@ -368,6 +393,12 @@ func (o EventArrayOutput) ToEventArrayOutputWithContext(ctx context.Context) Eve return o } +func (o EventArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Event] { + return pulumix.Output[[]*Event]{ + OutputState: o.OutputState, + } +} + func (o EventArrayOutput) Index(i pulumi.IntInput) EventOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Event { return vs[0].([]*Event)[vs[1].(int)] @@ -388,6 +419,12 @@ func (o EventMapOutput) ToEventMapOutputWithContext(ctx context.Context) EventMa return o } +func (o EventMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Event] { + return pulumix.Output[map[string]*Event]{ + OutputState: o.OutputState, + } +} + func (o EventMapOutput) MapIndex(k pulumi.StringInput) EventOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Event { return vs[0].(map[string]*Event)[vs[1].(string)] diff --git a/sdk/go/kubernetes/events/v1/eventList.go b/sdk/go/kubernetes/events/v1/eventList.go index 9fc2ab901d..05253c3b91 100644 --- a/sdk/go/kubernetes/events/v1/eventList.go +++ b/sdk/go/kubernetes/events/v1/eventList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EventList is a list of Event objects. @@ -117,6 +118,12 @@ func (i *EventList) ToEventListOutputWithContext(ctx context.Context) EventListO return pulumi.ToOutputWithContext(ctx, i).(EventListOutput) } +func (i *EventList) ToOutput(ctx context.Context) pulumix.Output[*EventList] { + return pulumix.Output[*EventList]{ + OutputState: i.ToEventListOutputWithContext(ctx).OutputState, + } +} + // EventListArrayInput is an input type that accepts EventListArray and EventListArrayOutput values. // You can construct a concrete instance of `EventListArrayInput` via: // @@ -142,6 +149,12 @@ func (i EventListArray) ToEventListArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EventListArrayOutput) } +func (i EventListArray) ToOutput(ctx context.Context) pulumix.Output[[]*EventList] { + return pulumix.Output[[]*EventList]{ + OutputState: i.ToEventListArrayOutputWithContext(ctx).OutputState, + } +} + // EventListMapInput is an input type that accepts EventListMap and EventListMapOutput values. // You can construct a concrete instance of `EventListMapInput` via: // @@ -167,6 +180,12 @@ func (i EventListMap) ToEventListMapOutputWithContext(ctx context.Context) Event return pulumi.ToOutputWithContext(ctx, i).(EventListMapOutput) } +func (i EventListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventList] { + return pulumix.Output[map[string]*EventList]{ + OutputState: i.ToEventListMapOutputWithContext(ctx).OutputState, + } +} + type EventListOutput struct{ *pulumi.OutputState } func (EventListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o EventListOutput) ToEventListOutputWithContext(ctx context.Context) Event return o } +func (o EventListOutput) ToOutput(ctx context.Context) pulumix.Output[*EventList] { + return pulumix.Output[*EventList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EventListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *EventList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o EventListArrayOutput) ToEventListArrayOutputWithContext(ctx context.Cont return o } +func (o EventListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EventList] { + return pulumix.Output[[]*EventList]{ + OutputState: o.OutputState, + } +} + func (o EventListArrayOutput) Index(i pulumi.IntInput) EventListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventList { return vs[0].([]*EventList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o EventListMapOutput) ToEventListMapOutputWithContext(ctx context.Context) return o } +func (o EventListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventList] { + return pulumix.Output[map[string]*EventList]{ + OutputState: o.OutputState, + } +} + func (o EventListMapOutput) MapIndex(k pulumi.StringInput) EventListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EventList { return vs[0].(map[string]*EventList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/events/v1/eventPatch.go b/sdk/go/kubernetes/events/v1/eventPatch.go index 8223cba8fb..4ce5b3d86b 100644 --- a/sdk/go/kubernetes/events/v1/eventPatch.go +++ b/sdk/go/kubernetes/events/v1/eventPatch.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -207,6 +208,12 @@ func (i *EventPatch) ToEventPatchOutputWithContext(ctx context.Context) EventPat return pulumi.ToOutputWithContext(ctx, i).(EventPatchOutput) } +func (i *EventPatch) ToOutput(ctx context.Context) pulumix.Output[*EventPatch] { + return pulumix.Output[*EventPatch]{ + OutputState: i.ToEventPatchOutputWithContext(ctx).OutputState, + } +} + // EventPatchArrayInput is an input type that accepts EventPatchArray and EventPatchArrayOutput values. // You can construct a concrete instance of `EventPatchArrayInput` via: // @@ -232,6 +239,12 @@ func (i EventPatchArray) ToEventPatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EventPatchArrayOutput) } +func (i EventPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*EventPatch] { + return pulumix.Output[[]*EventPatch]{ + OutputState: i.ToEventPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EventPatchMapInput is an input type that accepts EventPatchMap and EventPatchMapOutput values. // You can construct a concrete instance of `EventPatchMapInput` via: // @@ -257,6 +270,12 @@ func (i EventPatchMap) ToEventPatchMapOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventPatchMapOutput) } +func (i EventPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventPatch] { + return pulumix.Output[map[string]*EventPatch]{ + OutputState: i.ToEventPatchMapOutputWithContext(ctx).OutputState, + } +} + type EventPatchOutput struct{ *pulumi.OutputState } func (EventPatchOutput) ElementType() reflect.Type { @@ -271,6 +290,12 @@ func (o EventPatchOutput) ToEventPatchOutputWithContext(ctx context.Context) Eve return o } +func (o EventPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*EventPatch] { + return pulumix.Output[*EventPatch]{ + OutputState: o.OutputState, + } +} + // action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters. func (o EventPatchOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v *EventPatch) pulumi.StringPtrOutput { return v.Action }).(pulumi.StringPtrOutput) @@ -370,6 +395,12 @@ func (o EventPatchArrayOutput) ToEventPatchArrayOutputWithContext(ctx context.Co return o } +func (o EventPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EventPatch] { + return pulumix.Output[[]*EventPatch]{ + OutputState: o.OutputState, + } +} + func (o EventPatchArrayOutput) Index(i pulumi.IntInput) EventPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventPatch { return vs[0].([]*EventPatch)[vs[1].(int)] @@ -390,6 +421,12 @@ func (o EventPatchMapOutput) ToEventPatchMapOutputWithContext(ctx context.Contex return o } +func (o EventPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventPatch] { + return pulumix.Output[map[string]*EventPatch]{ + OutputState: o.OutputState, + } +} + func (o EventPatchMapOutput) MapIndex(k pulumi.StringInput) EventPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EventPatch { return vs[0].(map[string]*EventPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/events/v1/pulumiTypes.go b/sdk/go/kubernetes/events/v1/pulumiTypes.go index 0e3493d80e..126e0d4a67 100644 --- a/sdk/go/kubernetes/events/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/events/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -114,6 +115,12 @@ func (i EventTypeArgs) ToEventTypeOutputWithContext(ctx context.Context) EventTy return pulumi.ToOutputWithContext(ctx, i).(EventTypeOutput) } +func (i EventTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventType] { + return pulumix.Output[EventType]{ + OutputState: i.ToEventTypeOutputWithContext(ctx).OutputState, + } +} + // EventTypeArrayInput is an input type that accepts EventTypeArray and EventTypeArrayOutput values. // You can construct a concrete instance of `EventTypeArrayInput` via: // @@ -139,6 +146,12 @@ func (i EventTypeArray) ToEventTypeArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EventTypeArrayOutput) } +func (i EventTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]EventType] { + return pulumix.Output[[]EventType]{ + OutputState: i.ToEventTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. type EventTypeOutput struct{ *pulumi.OutputState } @@ -154,6 +167,12 @@ func (o EventTypeOutput) ToEventTypeOutputWithContext(ctx context.Context) Event return o } +func (o EventTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventType] { + return pulumix.Output[EventType]{ + OutputState: o.OutputState, + } +} + // action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters. func (o EventTypeOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v EventType) *string { return v.Action }).(pulumi.StringPtrOutput) @@ -253,6 +272,12 @@ func (o EventTypeArrayOutput) ToEventTypeArrayOutputWithContext(ctx context.Cont return o } +func (o EventTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EventType] { + return pulumix.Output[[]EventType]{ + OutputState: o.OutputState, + } +} + func (o EventTypeArrayOutput) Index(i pulumi.IntInput) EventTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EventType { return vs[0].([]EventType)[vs[1].(int)] @@ -306,6 +331,12 @@ func (i EventListTypeArgs) ToEventListTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EventListTypeOutput) } +func (i EventListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventListType] { + return pulumix.Output[EventListType]{ + OutputState: i.ToEventListTypeOutputWithContext(ctx).OutputState, + } +} + // EventList is a list of Event objects. type EventListTypeOutput struct{ *pulumi.OutputState } @@ -321,6 +352,12 @@ func (o EventListTypeOutput) ToEventListTypeOutputWithContext(ctx context.Contex return o } +func (o EventListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventListType] { + return pulumix.Output[EventListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EventListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EventListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -440,6 +477,12 @@ func (i EventPatchTypeArgs) ToEventPatchTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EventPatchTypeOutput) } +func (i EventPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventPatchType] { + return pulumix.Output[EventPatchType]{ + OutputState: i.ToEventPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. type EventPatchTypeOutput struct{ *pulumi.OutputState } @@ -455,6 +498,12 @@ func (o EventPatchTypeOutput) ToEventPatchTypeOutputWithContext(ctx context.Cont return o } +func (o EventPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventPatchType] { + return pulumix.Output[EventPatchType]{ + OutputState: o.OutputState, + } +} + // action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters. func (o EventPatchTypeOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v EventPatchType) *string { return v.Action }).(pulumi.StringPtrOutput) @@ -579,6 +628,12 @@ func (i EventSeriesArgs) ToEventSeriesOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventSeriesOutput) } +func (i EventSeriesArgs) ToOutput(ctx context.Context) pulumix.Output[EventSeries] { + return pulumix.Output[EventSeries]{ + OutputState: i.ToEventSeriesOutputWithContext(ctx).OutputState, + } +} + func (i EventSeriesArgs) ToEventSeriesPtrOutput() EventSeriesPtrOutput { return i.ToEventSeriesPtrOutputWithContext(context.Background()) } @@ -620,6 +675,12 @@ func (i *eventSeriesPtrType) ToEventSeriesPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPtrOutput) } +func (i *eventSeriesPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSeries] { + return pulumix.Output[*EventSeries]{ + OutputState: i.ToEventSeriesPtrOutputWithContext(ctx).OutputState, + } +} + // EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in "k8s.io/client-go/tools/events/event_broadcaster.go" shows how this struct is updated on heartbeats and can guide customized reporter implementations. type EventSeriesOutput struct{ *pulumi.OutputState } @@ -645,6 +706,12 @@ func (o EventSeriesOutput) ToEventSeriesPtrOutputWithContext(ctx context.Context }).(EventSeriesPtrOutput) } +func (o EventSeriesOutput) ToOutput(ctx context.Context) pulumix.Output[EventSeries] { + return pulumix.Output[EventSeries]{ + OutputState: o.OutputState, + } +} + // count is the number of occurrences in this series up to the last heartbeat time. func (o EventSeriesOutput) Count() pulumi.IntOutput { return o.ApplyT(func(v EventSeries) int { return v.Count }).(pulumi.IntOutput) @@ -669,6 +736,12 @@ func (o EventSeriesPtrOutput) ToEventSeriesPtrOutputWithContext(ctx context.Cont return o } +func (o EventSeriesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSeries] { + return pulumix.Output[*EventSeries]{ + OutputState: o.OutputState, + } +} + func (o EventSeriesPtrOutput) Elem() EventSeriesOutput { return o.ApplyT(func(v *EventSeries) EventSeries { if v != nil { @@ -738,6 +811,12 @@ func (i EventSeriesPatchArgs) ToEventSeriesPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPatchOutput) } +func (i EventSeriesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EventSeriesPatch] { + return pulumix.Output[EventSeriesPatch]{ + OutputState: i.ToEventSeriesPatchOutputWithContext(ctx).OutputState, + } +} + func (i EventSeriesPatchArgs) ToEventSeriesPatchPtrOutput() EventSeriesPatchPtrOutput { return i.ToEventSeriesPatchPtrOutputWithContext(context.Background()) } @@ -779,6 +858,12 @@ func (i *eventSeriesPatchPtrType) ToEventSeriesPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPatchPtrOutput) } +func (i *eventSeriesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSeriesPatch] { + return pulumix.Output[*EventSeriesPatch]{ + OutputState: i.ToEventSeriesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in "k8s.io/client-go/tools/events/event_broadcaster.go" shows how this struct is updated on heartbeats and can guide customized reporter implementations. type EventSeriesPatchOutput struct{ *pulumi.OutputState } @@ -804,6 +889,12 @@ func (o EventSeriesPatchOutput) ToEventSeriesPatchPtrOutputWithContext(ctx conte }).(EventSeriesPatchPtrOutput) } +func (o EventSeriesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EventSeriesPatch] { + return pulumix.Output[EventSeriesPatch]{ + OutputState: o.OutputState, + } +} + // count is the number of occurrences in this series up to the last heartbeat time. func (o EventSeriesPatchOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v EventSeriesPatch) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -828,6 +919,12 @@ func (o EventSeriesPatchPtrOutput) ToEventSeriesPatchPtrOutputWithContext(ctx co return o } +func (o EventSeriesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSeriesPatch] { + return pulumix.Output[*EventSeriesPatch]{ + OutputState: o.OutputState, + } +} + func (o EventSeriesPatchPtrOutput) Elem() EventSeriesPatchOutput { return o.ApplyT(func(v *EventSeriesPatch) EventSeriesPatch { if v != nil { diff --git a/sdk/go/kubernetes/events/v1beta1/event.go b/sdk/go/kubernetes/events/v1beta1/event.go index 235b697c1d..e68b2995fa 100644 --- a/sdk/go/kubernetes/events/v1beta1/event.go +++ b/sdk/go/kubernetes/events/v1beta1/event.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. @@ -202,6 +203,12 @@ func (i *Event) ToEventOutputWithContext(ctx context.Context) EventOutput { return pulumi.ToOutputWithContext(ctx, i).(EventOutput) } +func (i *Event) ToOutput(ctx context.Context) pulumix.Output[*Event] { + return pulumix.Output[*Event]{ + OutputState: i.ToEventOutputWithContext(ctx).OutputState, + } +} + // EventArrayInput is an input type that accepts EventArray and EventArrayOutput values. // You can construct a concrete instance of `EventArrayInput` via: // @@ -227,6 +234,12 @@ func (i EventArray) ToEventArrayOutputWithContext(ctx context.Context) EventArra return pulumi.ToOutputWithContext(ctx, i).(EventArrayOutput) } +func (i EventArray) ToOutput(ctx context.Context) pulumix.Output[[]*Event] { + return pulumix.Output[[]*Event]{ + OutputState: i.ToEventArrayOutputWithContext(ctx).OutputState, + } +} + // EventMapInput is an input type that accepts EventMap and EventMapOutput values. // You can construct a concrete instance of `EventMapInput` via: // @@ -252,6 +265,12 @@ func (i EventMap) ToEventMapOutputWithContext(ctx context.Context) EventMapOutpu return pulumi.ToOutputWithContext(ctx, i).(EventMapOutput) } +func (i EventMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Event] { + return pulumix.Output[map[string]*Event]{ + OutputState: i.ToEventMapOutputWithContext(ctx).OutputState, + } +} + type EventOutput struct{ *pulumi.OutputState } func (EventOutput) ElementType() reflect.Type { @@ -266,6 +285,12 @@ func (o EventOutput) ToEventOutputWithContext(ctx context.Context) EventOutput { return o } +func (o EventOutput) ToOutput(ctx context.Context) pulumix.Output[*Event] { + return pulumix.Output[*Event]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the regarding object. func (o EventOutput) Action() pulumi.StringOutput { return o.ApplyT(func(v *Event) pulumi.StringOutput { return v.Action }).(pulumi.StringOutput) @@ -364,6 +389,12 @@ func (o EventArrayOutput) ToEventArrayOutputWithContext(ctx context.Context) Eve return o } +func (o EventArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Event] { + return pulumix.Output[[]*Event]{ + OutputState: o.OutputState, + } +} + func (o EventArrayOutput) Index(i pulumi.IntInput) EventOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Event { return vs[0].([]*Event)[vs[1].(int)] @@ -384,6 +415,12 @@ func (o EventMapOutput) ToEventMapOutputWithContext(ctx context.Context) EventMa return o } +func (o EventMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Event] { + return pulumix.Output[map[string]*Event]{ + OutputState: o.OutputState, + } +} + func (o EventMapOutput) MapIndex(k pulumi.StringInput) EventOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Event { return vs[0].(map[string]*Event)[vs[1].(string)] diff --git a/sdk/go/kubernetes/events/v1beta1/eventList.go b/sdk/go/kubernetes/events/v1beta1/eventList.go index b0bfc19541..11beb63e42 100644 --- a/sdk/go/kubernetes/events/v1beta1/eventList.go +++ b/sdk/go/kubernetes/events/v1beta1/eventList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // EventList is a list of Event objects. @@ -117,6 +118,12 @@ func (i *EventList) ToEventListOutputWithContext(ctx context.Context) EventListO return pulumi.ToOutputWithContext(ctx, i).(EventListOutput) } +func (i *EventList) ToOutput(ctx context.Context) pulumix.Output[*EventList] { + return pulumix.Output[*EventList]{ + OutputState: i.ToEventListOutputWithContext(ctx).OutputState, + } +} + // EventListArrayInput is an input type that accepts EventListArray and EventListArrayOutput values. // You can construct a concrete instance of `EventListArrayInput` via: // @@ -142,6 +149,12 @@ func (i EventListArray) ToEventListArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EventListArrayOutput) } +func (i EventListArray) ToOutput(ctx context.Context) pulumix.Output[[]*EventList] { + return pulumix.Output[[]*EventList]{ + OutputState: i.ToEventListArrayOutputWithContext(ctx).OutputState, + } +} + // EventListMapInput is an input type that accepts EventListMap and EventListMapOutput values. // You can construct a concrete instance of `EventListMapInput` via: // @@ -167,6 +180,12 @@ func (i EventListMap) ToEventListMapOutputWithContext(ctx context.Context) Event return pulumi.ToOutputWithContext(ctx, i).(EventListMapOutput) } +func (i EventListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventList] { + return pulumix.Output[map[string]*EventList]{ + OutputState: i.ToEventListMapOutputWithContext(ctx).OutputState, + } +} + type EventListOutput struct{ *pulumi.OutputState } func (EventListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o EventListOutput) ToEventListOutputWithContext(ctx context.Context) Event return o } +func (o EventListOutput) ToOutput(ctx context.Context) pulumix.Output[*EventList] { + return pulumix.Output[*EventList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EventListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *EventList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o EventListArrayOutput) ToEventListArrayOutputWithContext(ctx context.Cont return o } +func (o EventListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EventList] { + return pulumix.Output[[]*EventList]{ + OutputState: o.OutputState, + } +} + func (o EventListArrayOutput) Index(i pulumi.IntInput) EventListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventList { return vs[0].([]*EventList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o EventListMapOutput) ToEventListMapOutputWithContext(ctx context.Context) return o } +func (o EventListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventList] { + return pulumix.Output[map[string]*EventList]{ + OutputState: o.OutputState, + } +} + func (o EventListMapOutput) MapIndex(k pulumi.StringInput) EventListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EventList { return vs[0].(map[string]*EventList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/events/v1beta1/eventPatch.go b/sdk/go/kubernetes/events/v1beta1/eventPatch.go index 931a41299c..9d5e33dc2b 100644 --- a/sdk/go/kubernetes/events/v1beta1/eventPatch.go +++ b/sdk/go/kubernetes/events/v1beta1/eventPatch.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -204,6 +205,12 @@ func (i *EventPatch) ToEventPatchOutputWithContext(ctx context.Context) EventPat return pulumi.ToOutputWithContext(ctx, i).(EventPatchOutput) } +func (i *EventPatch) ToOutput(ctx context.Context) pulumix.Output[*EventPatch] { + return pulumix.Output[*EventPatch]{ + OutputState: i.ToEventPatchOutputWithContext(ctx).OutputState, + } +} + // EventPatchArrayInput is an input type that accepts EventPatchArray and EventPatchArrayOutput values. // You can construct a concrete instance of `EventPatchArrayInput` via: // @@ -229,6 +236,12 @@ func (i EventPatchArray) ToEventPatchArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EventPatchArrayOutput) } +func (i EventPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*EventPatch] { + return pulumix.Output[[]*EventPatch]{ + OutputState: i.ToEventPatchArrayOutputWithContext(ctx).OutputState, + } +} + // EventPatchMapInput is an input type that accepts EventPatchMap and EventPatchMapOutput values. // You can construct a concrete instance of `EventPatchMapInput` via: // @@ -254,6 +267,12 @@ func (i EventPatchMap) ToEventPatchMapOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventPatchMapOutput) } +func (i EventPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventPatch] { + return pulumix.Output[map[string]*EventPatch]{ + OutputState: i.ToEventPatchMapOutputWithContext(ctx).OutputState, + } +} + type EventPatchOutput struct{ *pulumi.OutputState } func (EventPatchOutput) ElementType() reflect.Type { @@ -268,6 +287,12 @@ func (o EventPatchOutput) ToEventPatchOutputWithContext(ctx context.Context) Eve return o } +func (o EventPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*EventPatch] { + return pulumix.Output[*EventPatch]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the regarding object. func (o EventPatchOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v *EventPatch) pulumi.StringPtrOutput { return v.Action }).(pulumi.StringPtrOutput) @@ -366,6 +391,12 @@ func (o EventPatchArrayOutput) ToEventPatchArrayOutputWithContext(ctx context.Co return o } +func (o EventPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EventPatch] { + return pulumix.Output[[]*EventPatch]{ + OutputState: o.OutputState, + } +} + func (o EventPatchArrayOutput) Index(i pulumi.IntInput) EventPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventPatch { return vs[0].([]*EventPatch)[vs[1].(int)] @@ -386,6 +417,12 @@ func (o EventPatchMapOutput) ToEventPatchMapOutputWithContext(ctx context.Contex return o } +func (o EventPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EventPatch] { + return pulumix.Output[map[string]*EventPatch]{ + OutputState: o.OutputState, + } +} + func (o EventPatchMapOutput) MapIndex(k pulumi.StringInput) EventPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EventPatch { return vs[0].(map[string]*EventPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/events/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/events/v1beta1/pulumiTypes.go index 9deca3e330..8337eae715 100644 --- a/sdk/go/kubernetes/events/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/events/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -112,6 +113,12 @@ func (i EventTypeArgs) ToEventTypeOutputWithContext(ctx context.Context) EventTy return pulumi.ToOutputWithContext(ctx, i).(EventTypeOutput) } +func (i EventTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventType] { + return pulumix.Output[EventType]{ + OutputState: i.ToEventTypeOutputWithContext(ctx).OutputState, + } +} + // EventTypeArrayInput is an input type that accepts EventTypeArray and EventTypeArrayOutput values. // You can construct a concrete instance of `EventTypeArrayInput` via: // @@ -137,6 +144,12 @@ func (i EventTypeArray) ToEventTypeArrayOutputWithContext(ctx context.Context) E return pulumi.ToOutputWithContext(ctx, i).(EventTypeArrayOutput) } +func (i EventTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]EventType] { + return pulumix.Output[[]EventType]{ + OutputState: i.ToEventTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. type EventTypeOutput struct{ *pulumi.OutputState } @@ -152,6 +165,12 @@ func (o EventTypeOutput) ToEventTypeOutputWithContext(ctx context.Context) Event return o } +func (o EventTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventType] { + return pulumix.Output[EventType]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the regarding object. func (o EventTypeOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v EventType) *string { return v.Action }).(pulumi.StringPtrOutput) @@ -250,6 +269,12 @@ func (o EventTypeArrayOutput) ToEventTypeArrayOutputWithContext(ctx context.Cont return o } +func (o EventTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]EventType] { + return pulumix.Output[[]EventType]{ + OutputState: o.OutputState, + } +} + func (o EventTypeArrayOutput) Index(i pulumi.IntInput) EventTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) EventType { return vs[0].([]EventType)[vs[1].(int)] @@ -303,6 +328,12 @@ func (i EventListTypeArgs) ToEventListTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EventListTypeOutput) } +func (i EventListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventListType] { + return pulumix.Output[EventListType]{ + OutputState: i.ToEventListTypeOutputWithContext(ctx).OutputState, + } +} + // EventList is a list of Event objects. type EventListTypeOutput struct{ *pulumi.OutputState } @@ -318,6 +349,12 @@ func (o EventListTypeOutput) ToEventListTypeOutputWithContext(ctx context.Contex return o } +func (o EventListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventListType] { + return pulumix.Output[EventListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EventListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EventListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -435,6 +472,12 @@ func (i EventPatchTypeArgs) ToEventPatchTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(EventPatchTypeOutput) } +func (i EventPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[EventPatchType] { + return pulumix.Output[EventPatchType]{ + OutputState: i.ToEventPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. type EventPatchTypeOutput struct{ *pulumi.OutputState } @@ -450,6 +493,12 @@ func (o EventPatchTypeOutput) ToEventPatchTypeOutputWithContext(ctx context.Cont return o } +func (o EventPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[EventPatchType] { + return pulumix.Output[EventPatchType]{ + OutputState: o.OutputState, + } +} + // What action was taken/failed regarding to the regarding object. func (o EventPatchTypeOutput) Action() pulumi.StringPtrOutput { return o.ApplyT(func(v EventPatchType) *string { return v.Action }).(pulumi.StringPtrOutput) @@ -577,6 +626,12 @@ func (i EventSeriesArgs) ToEventSeriesOutputWithContext(ctx context.Context) Eve return pulumi.ToOutputWithContext(ctx, i).(EventSeriesOutput) } +func (i EventSeriesArgs) ToOutput(ctx context.Context) pulumix.Output[EventSeries] { + return pulumix.Output[EventSeries]{ + OutputState: i.ToEventSeriesOutputWithContext(ctx).OutputState, + } +} + func (i EventSeriesArgs) ToEventSeriesPtrOutput() EventSeriesPtrOutput { return i.ToEventSeriesPtrOutputWithContext(context.Background()) } @@ -618,6 +673,12 @@ func (i *eventSeriesPtrType) ToEventSeriesPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPtrOutput) } +func (i *eventSeriesPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSeries] { + return pulumix.Output[*EventSeries]{ + OutputState: i.ToEventSeriesPtrOutputWithContext(ctx).OutputState, + } +} + // EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. type EventSeriesOutput struct{ *pulumi.OutputState } @@ -643,6 +704,12 @@ func (o EventSeriesOutput) ToEventSeriesPtrOutputWithContext(ctx context.Context }).(EventSeriesPtrOutput) } +func (o EventSeriesOutput) ToOutput(ctx context.Context) pulumix.Output[EventSeries] { + return pulumix.Output[EventSeries]{ + OutputState: o.OutputState, + } +} + // Number of occurrences in this series up to the last heartbeat time func (o EventSeriesOutput) Count() pulumi.IntOutput { return o.ApplyT(func(v EventSeries) int { return v.Count }).(pulumi.IntOutput) @@ -672,6 +739,12 @@ func (o EventSeriesPtrOutput) ToEventSeriesPtrOutputWithContext(ctx context.Cont return o } +func (o EventSeriesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSeries] { + return pulumix.Output[*EventSeries]{ + OutputState: o.OutputState, + } +} + func (o EventSeriesPtrOutput) Elem() EventSeriesOutput { return o.ApplyT(func(v *EventSeries) EventSeries { if v != nil { @@ -755,6 +828,12 @@ func (i EventSeriesPatchArgs) ToEventSeriesPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPatchOutput) } +func (i EventSeriesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EventSeriesPatch] { + return pulumix.Output[EventSeriesPatch]{ + OutputState: i.ToEventSeriesPatchOutputWithContext(ctx).OutputState, + } +} + func (i EventSeriesPatchArgs) ToEventSeriesPatchPtrOutput() EventSeriesPatchPtrOutput { return i.ToEventSeriesPatchPtrOutputWithContext(context.Background()) } @@ -796,6 +875,12 @@ func (i *eventSeriesPatchPtrType) ToEventSeriesPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(EventSeriesPatchPtrOutput) } +func (i *eventSeriesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*EventSeriesPatch] { + return pulumix.Output[*EventSeriesPatch]{ + OutputState: i.ToEventSeriesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. type EventSeriesPatchOutput struct{ *pulumi.OutputState } @@ -821,6 +906,12 @@ func (o EventSeriesPatchOutput) ToEventSeriesPatchPtrOutputWithContext(ctx conte }).(EventSeriesPatchPtrOutput) } +func (o EventSeriesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EventSeriesPatch] { + return pulumix.Output[EventSeriesPatch]{ + OutputState: o.OutputState, + } +} + // Number of occurrences in this series up to the last heartbeat time func (o EventSeriesPatchOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v EventSeriesPatch) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -850,6 +941,12 @@ func (o EventSeriesPatchPtrOutput) ToEventSeriesPatchPtrOutputWithContext(ctx co return o } +func (o EventSeriesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*EventSeriesPatch] { + return pulumix.Output[*EventSeriesPatch]{ + OutputState: o.OutputState, + } +} + func (o EventSeriesPatchPtrOutput) Elem() EventSeriesPatchOutput { return o.ApplyT(func(v *EventSeriesPatch) EventSeriesPatch { if v != nil { diff --git a/sdk/go/kubernetes/extensions/v1beta1/daemonSet.go b/sdk/go/kubernetes/extensions/v1beta1/daemonSet.go index 7b149ed303..54977e131d 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/daemonSet.go +++ b/sdk/go/kubernetes/extensions/v1beta1/daemonSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DaemonSet represents the configuration of a daemon set. @@ -126,6 +127,12 @@ func (i *DaemonSet) ToDaemonSetOutputWithContext(ctx context.Context) DaemonSetO return pulumi.ToOutputWithContext(ctx, i).(DaemonSetOutput) } +func (i *DaemonSet) ToOutput(ctx context.Context) pulumix.Output[*DaemonSet] { + return pulumix.Output[*DaemonSet]{ + OutputState: i.ToDaemonSetOutputWithContext(ctx).OutputState, + } +} + // DaemonSetArrayInput is an input type that accepts DaemonSetArray and DaemonSetArrayOutput values. // You can construct a concrete instance of `DaemonSetArrayInput` via: // @@ -151,6 +158,12 @@ func (i DaemonSetArray) ToDaemonSetArrayOutputWithContext(ctx context.Context) D return pulumi.ToOutputWithContext(ctx, i).(DaemonSetArrayOutput) } +func (i DaemonSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSet] { + return pulumix.Output[[]*DaemonSet]{ + OutputState: i.ToDaemonSetArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetMapInput is an input type that accepts DaemonSetMap and DaemonSetMapOutput values. // You can construct a concrete instance of `DaemonSetMapInput` via: // @@ -176,6 +189,12 @@ func (i DaemonSetMap) ToDaemonSetMapOutputWithContext(ctx context.Context) Daemo return pulumi.ToOutputWithContext(ctx, i).(DaemonSetMapOutput) } +func (i DaemonSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSet] { + return pulumix.Output[map[string]*DaemonSet]{ + OutputState: i.ToDaemonSetMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetOutput struct{ *pulumi.OutputState } func (DaemonSetOutput) ElementType() reflect.Type { @@ -190,6 +209,12 @@ func (o DaemonSetOutput) ToDaemonSetOutputWithContext(ctx context.Context) Daemo return o } +func (o DaemonSetOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSet] { + return pulumix.Output[*DaemonSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DaemonSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -229,6 +254,12 @@ func (o DaemonSetArrayOutput) ToDaemonSetArrayOutputWithContext(ctx context.Cont return o } +func (o DaemonSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSet] { + return pulumix.Output[[]*DaemonSet]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetArrayOutput) Index(i pulumi.IntInput) DaemonSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSet { return vs[0].([]*DaemonSet)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o DaemonSetMapOutput) ToDaemonSetMapOutputWithContext(ctx context.Context) return o } +func (o DaemonSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSet] { + return pulumix.Output[map[string]*DaemonSet]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetMapOutput) MapIndex(k pulumi.StringInput) DaemonSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSet { return vs[0].(map[string]*DaemonSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/daemonSetList.go b/sdk/go/kubernetes/extensions/v1beta1/daemonSetList.go index b33e2d21ad..32932a59cd 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/daemonSetList.go +++ b/sdk/go/kubernetes/extensions/v1beta1/daemonSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DaemonSetList is a collection of daemon sets. @@ -117,6 +118,12 @@ func (i *DaemonSetList) ToDaemonSetListOutputWithContext(ctx context.Context) Da return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListOutput) } +func (i *DaemonSetList) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetList] { + return pulumix.Output[*DaemonSetList]{ + OutputState: i.ToDaemonSetListOutputWithContext(ctx).OutputState, + } +} + // DaemonSetListArrayInput is an input type that accepts DaemonSetListArray and DaemonSetListArrayOutput values. // You can construct a concrete instance of `DaemonSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DaemonSetListArray) ToDaemonSetListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListArrayOutput) } +func (i DaemonSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetList] { + return pulumix.Output[[]*DaemonSetList]{ + OutputState: i.ToDaemonSetListArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetListMapInput is an input type that accepts DaemonSetListMap and DaemonSetListMapOutput values. // You can construct a concrete instance of `DaemonSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i DaemonSetListMap) ToDaemonSetListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListMapOutput) } +func (i DaemonSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetList] { + return pulumix.Output[map[string]*DaemonSetList]{ + OutputState: i.ToDaemonSetListMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetListOutput struct{ *pulumi.OutputState } func (DaemonSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DaemonSetListOutput) ToDaemonSetListOutputWithContext(ctx context.Contex return o } +func (o DaemonSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetList] { + return pulumix.Output[*DaemonSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DaemonSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DaemonSetListArrayOutput) ToDaemonSetListArrayOutputWithContext(ctx cont return o } +func (o DaemonSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetList] { + return pulumix.Output[[]*DaemonSetList]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetListArrayOutput) Index(i pulumi.IntInput) DaemonSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSetList { return vs[0].([]*DaemonSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DaemonSetListMapOutput) ToDaemonSetListMapOutputWithContext(ctx context. return o } +func (o DaemonSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetList] { + return pulumix.Output[map[string]*DaemonSetList]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetListMapOutput) MapIndex(k pulumi.StringInput) DaemonSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSetList { return vs[0].(map[string]*DaemonSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/daemonSetPatch.go b/sdk/go/kubernetes/extensions/v1beta1/daemonSetPatch.go index ff374e8c81..aece4539c8 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/daemonSetPatch.go +++ b/sdk/go/kubernetes/extensions/v1beta1/daemonSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *DaemonSetPatch) ToDaemonSetPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchOutput) } +func (i *DaemonSetPatch) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetPatch] { + return pulumix.Output[*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchOutputWithContext(ctx).OutputState, + } +} + // DaemonSetPatchArrayInput is an input type that accepts DaemonSetPatchArray and DaemonSetPatchArrayOutput values. // You can construct a concrete instance of `DaemonSetPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i DaemonSetPatchArray) ToDaemonSetPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchArrayOutput) } +func (i DaemonSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetPatch] { + return pulumix.Output[[]*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetPatchMapInput is an input type that accepts DaemonSetPatchMap and DaemonSetPatchMapOutput values. // You can construct a concrete instance of `DaemonSetPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i DaemonSetPatchMap) ToDaemonSetPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchMapOutput) } +func (i DaemonSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetPatch] { + return pulumix.Output[map[string]*DaemonSetPatch]{ + OutputState: i.ToDaemonSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type DaemonSetPatchOutput struct{ *pulumi.OutputState } func (DaemonSetPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o DaemonSetPatchOutput) ToDaemonSetPatchOutputWithContext(ctx context.Cont return o } +func (o DaemonSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetPatch] { + return pulumix.Output[*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DaemonSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o DaemonSetPatchArrayOutput) ToDaemonSetPatchArrayOutputWithContext(ctx co return o } +func (o DaemonSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DaemonSetPatch] { + return pulumix.Output[[]*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetPatchArrayOutput) Index(i pulumi.IntInput) DaemonSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DaemonSetPatch { return vs[0].([]*DaemonSetPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o DaemonSetPatchMapOutput) ToDaemonSetPatchMapOutputWithContext(ctx contex return o } +func (o DaemonSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DaemonSetPatch] { + return pulumix.Output[map[string]*DaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetPatchMapOutput) MapIndex(k pulumi.StringInput) DaemonSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DaemonSetPatch { return vs[0].(map[string]*DaemonSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/deployment.go b/sdk/go/kubernetes/extensions/v1beta1/deployment.go index eaa1234373..febb37693a 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/deployment.go +++ b/sdk/go/kubernetes/extensions/v1beta1/deployment.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Deployment enables declarative updates for Pods and ReplicaSets. @@ -151,6 +152,12 @@ func (i *Deployment) ToDeploymentOutputWithContext(ctx context.Context) Deployme return pulumi.ToOutputWithContext(ctx, i).(DeploymentOutput) } +func (i *Deployment) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: i.ToDeploymentOutputWithContext(ctx).OutputState, + } +} + // DeploymentArrayInput is an input type that accepts DeploymentArray and DeploymentArrayOutput values. // You can construct a concrete instance of `DeploymentArrayInput` via: // @@ -176,6 +183,12 @@ func (i DeploymentArray) ToDeploymentArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentArrayOutput) } +func (i DeploymentArray) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: i.ToDeploymentArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentMapInput is an input type that accepts DeploymentMap and DeploymentMapOutput values. // You can construct a concrete instance of `DeploymentMapInput` via: // @@ -201,6 +214,12 @@ func (i DeploymentMap) ToDeploymentMapOutputWithContext(ctx context.Context) Dep return pulumi.ToOutputWithContext(ctx, i).(DeploymentMapOutput) } +func (i DeploymentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: i.ToDeploymentMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentOutput struct{ *pulumi.OutputState } func (DeploymentOutput) ElementType() reflect.Type { @@ -215,6 +234,12 @@ func (o DeploymentOutput) ToDeploymentOutputWithContext(ctx context.Context) Dep return o } +func (o DeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[*Deployment] { + return pulumix.Output[*Deployment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Deployment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -254,6 +279,12 @@ func (o DeploymentArrayOutput) ToDeploymentArrayOutputWithContext(ctx context.Co return o } +func (o DeploymentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Deployment] { + return pulumix.Output[[]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentArrayOutput) Index(i pulumi.IntInput) DeploymentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Deployment { return vs[0].([]*Deployment)[vs[1].(int)] @@ -274,6 +305,12 @@ func (o DeploymentMapOutput) ToDeploymentMapOutputWithContext(ctx context.Contex return o } +func (o DeploymentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Deployment] { + return pulumix.Output[map[string]*Deployment]{ + OutputState: o.OutputState, + } +} + func (o DeploymentMapOutput) MapIndex(k pulumi.StringInput) DeploymentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Deployment { return vs[0].(map[string]*Deployment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/deploymentList.go b/sdk/go/kubernetes/extensions/v1beta1/deploymentList.go index da719dda8b..71746d387b 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/deploymentList.go +++ b/sdk/go/kubernetes/extensions/v1beta1/deploymentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DeploymentList is a list of Deployments. @@ -117,6 +118,12 @@ func (i *DeploymentList) ToDeploymentListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeploymentListOutput) } +func (i *DeploymentList) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: i.ToDeploymentListOutputWithContext(ctx).OutputState, + } +} + // DeploymentListArrayInput is an input type that accepts DeploymentListArray and DeploymentListArrayOutput values. // You can construct a concrete instance of `DeploymentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i DeploymentListArray) ToDeploymentListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentListArrayOutput) } +func (i DeploymentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: i.ToDeploymentListArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentListMapInput is an input type that accepts DeploymentListMap and DeploymentListMapOutput values. // You can construct a concrete instance of `DeploymentListMapInput` via: // @@ -167,6 +180,12 @@ func (i DeploymentListMap) ToDeploymentListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentListMapOutput) } +func (i DeploymentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: i.ToDeploymentListMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentListOutput struct{ *pulumi.OutputState } func (DeploymentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o DeploymentListOutput) ToDeploymentListOutputWithContext(ctx context.Cont return o } +func (o DeploymentListOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentList] { + return pulumix.Output[*DeploymentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *DeploymentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o DeploymentListArrayOutput) ToDeploymentListArrayOutputWithContext(ctx co return o } +func (o DeploymentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentList] { + return pulumix.Output[[]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListArrayOutput) Index(i pulumi.IntInput) DeploymentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].([]*DeploymentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o DeploymentListMapOutput) ToDeploymentListMapOutputWithContext(ctx contex return o } +func (o DeploymentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentList] { + return pulumix.Output[map[string]*DeploymentList]{ + OutputState: o.OutputState, + } +} + func (o DeploymentListMapOutput) MapIndex(k pulumi.StringInput) DeploymentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentList { return vs[0].(map[string]*DeploymentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/deploymentPatch.go b/sdk/go/kubernetes/extensions/v1beta1/deploymentPatch.go index 7dbcabf861..db94bc3bc5 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/deploymentPatch.go +++ b/sdk/go/kubernetes/extensions/v1beta1/deploymentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -157,6 +158,12 @@ func (i *DeploymentPatch) ToDeploymentPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchOutput) } +func (i *DeploymentPatch) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchArrayInput is an input type that accepts DeploymentPatchArray and DeploymentPatchArrayOutput values. // You can construct a concrete instance of `DeploymentPatchArrayInput` via: // @@ -182,6 +189,12 @@ func (i DeploymentPatchArray) ToDeploymentPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchArrayOutput) } +func (i DeploymentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentPatchMapInput is an input type that accepts DeploymentPatchMap and DeploymentPatchMapOutput values. // You can construct a concrete instance of `DeploymentPatchMapInput` via: // @@ -207,6 +220,12 @@ func (i DeploymentPatchMap) ToDeploymentPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchMapOutput) } +func (i DeploymentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: i.ToDeploymentPatchMapOutputWithContext(ctx).OutputState, + } +} + type DeploymentPatchOutput struct{ *pulumi.OutputState } func (DeploymentPatchOutput) ElementType() reflect.Type { @@ -221,6 +240,12 @@ func (o DeploymentPatchOutput) ToDeploymentPatchOutputWithContext(ctx context.Co return o } +func (o DeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentPatch] { + return pulumix.Output[*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *DeploymentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -260,6 +285,12 @@ func (o DeploymentPatchArrayOutput) ToDeploymentPatchArrayOutputWithContext(ctx return o } +func (o DeploymentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DeploymentPatch] { + return pulumix.Output[[]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchArrayOutput) Index(i pulumi.IntInput) DeploymentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].([]*DeploymentPatch)[vs[1].(int)] @@ -280,6 +311,12 @@ func (o DeploymentPatchMapOutput) ToDeploymentPatchMapOutputWithContext(ctx cont return o } +func (o DeploymentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DeploymentPatch] { + return pulumix.Output[map[string]*DeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentPatchMapOutput) MapIndex(k pulumi.StringInput) DeploymentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DeploymentPatch { return vs[0].(map[string]*DeploymentPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/ingress.go b/sdk/go/kubernetes/extensions/v1beta1/ingress.go index 9adc422f17..effc1c7b14 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/ingress.go +++ b/sdk/go/kubernetes/extensions/v1beta1/ingress.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. @@ -140,6 +141,12 @@ func (i *Ingress) ToIngressOutputWithContext(ctx context.Context) IngressOutput return pulumi.ToOutputWithContext(ctx, i).(IngressOutput) } +func (i *Ingress) ToOutput(ctx context.Context) pulumix.Output[*Ingress] { + return pulumix.Output[*Ingress]{ + OutputState: i.ToIngressOutputWithContext(ctx).OutputState, + } +} + // IngressArrayInput is an input type that accepts IngressArray and IngressArrayOutput values. // You can construct a concrete instance of `IngressArrayInput` via: // @@ -165,6 +172,12 @@ func (i IngressArray) ToIngressArrayOutputWithContext(ctx context.Context) Ingre return pulumi.ToOutputWithContext(ctx, i).(IngressArrayOutput) } +func (i IngressArray) ToOutput(ctx context.Context) pulumix.Output[[]*Ingress] { + return pulumix.Output[[]*Ingress]{ + OutputState: i.ToIngressArrayOutputWithContext(ctx).OutputState, + } +} + // IngressMapInput is an input type that accepts IngressMap and IngressMapOutput values. // You can construct a concrete instance of `IngressMapInput` via: // @@ -190,6 +203,12 @@ func (i IngressMap) ToIngressMapOutputWithContext(ctx context.Context) IngressMa return pulumi.ToOutputWithContext(ctx, i).(IngressMapOutput) } +func (i IngressMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Ingress] { + return pulumix.Output[map[string]*Ingress]{ + OutputState: i.ToIngressMapOutputWithContext(ctx).OutputState, + } +} + type IngressOutput struct{ *pulumi.OutputState } func (IngressOutput) ElementType() reflect.Type { @@ -204,6 +223,12 @@ func (o IngressOutput) ToIngressOutputWithContext(ctx context.Context) IngressOu return o } +func (o IngressOutput) ToOutput(ctx context.Context) pulumix.Output[*Ingress] { + return pulumix.Output[*Ingress]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Ingress) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -243,6 +268,12 @@ func (o IngressArrayOutput) ToIngressArrayOutputWithContext(ctx context.Context) return o } +func (o IngressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Ingress] { + return pulumix.Output[[]*Ingress]{ + OutputState: o.OutputState, + } +} + func (o IngressArrayOutput) Index(i pulumi.IntInput) IngressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Ingress { return vs[0].([]*Ingress)[vs[1].(int)] @@ -263,6 +294,12 @@ func (o IngressMapOutput) ToIngressMapOutputWithContext(ctx context.Context) Ing return o } +func (o IngressMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Ingress] { + return pulumix.Output[map[string]*Ingress]{ + OutputState: o.OutputState, + } +} + func (o IngressMapOutput) MapIndex(k pulumi.StringInput) IngressOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Ingress { return vs[0].(map[string]*Ingress)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/ingressList.go b/sdk/go/kubernetes/extensions/v1beta1/ingressList.go index a95a497a67..1cf155f367 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/ingressList.go +++ b/sdk/go/kubernetes/extensions/v1beta1/ingressList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressList is a collection of Ingress. @@ -117,6 +118,12 @@ func (i *IngressList) ToIngressListOutputWithContext(ctx context.Context) Ingres return pulumi.ToOutputWithContext(ctx, i).(IngressListOutput) } +func (i *IngressList) ToOutput(ctx context.Context) pulumix.Output[*IngressList] { + return pulumix.Output[*IngressList]{ + OutputState: i.ToIngressListOutputWithContext(ctx).OutputState, + } +} + // IngressListArrayInput is an input type that accepts IngressListArray and IngressListArrayOutput values. // You can construct a concrete instance of `IngressListArrayInput` via: // @@ -142,6 +149,12 @@ func (i IngressListArray) ToIngressListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressListArrayOutput) } +func (i IngressListArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressList] { + return pulumix.Output[[]*IngressList]{ + OutputState: i.ToIngressListArrayOutputWithContext(ctx).OutputState, + } +} + // IngressListMapInput is an input type that accepts IngressListMap and IngressListMapOutput values. // You can construct a concrete instance of `IngressListMapInput` via: // @@ -167,6 +180,12 @@ func (i IngressListMap) ToIngressListMapOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IngressListMapOutput) } +func (i IngressListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressList] { + return pulumix.Output[map[string]*IngressList]{ + OutputState: i.ToIngressListMapOutputWithContext(ctx).OutputState, + } +} + type IngressListOutput struct{ *pulumi.OutputState } func (IngressListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o IngressListOutput) ToIngressListOutputWithContext(ctx context.Context) I return o } +func (o IngressListOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressList] { + return pulumix.Output[*IngressList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o IngressListArrayOutput) ToIngressListArrayOutputWithContext(ctx context. return o } +func (o IngressListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressList] { + return pulumix.Output[[]*IngressList]{ + OutputState: o.OutputState, + } +} + func (o IngressListArrayOutput) Index(i pulumi.IntInput) IngressListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressList { return vs[0].([]*IngressList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o IngressListMapOutput) ToIngressListMapOutputWithContext(ctx context.Cont return o } +func (o IngressListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressList] { + return pulumix.Output[map[string]*IngressList]{ + OutputState: o.OutputState, + } +} + func (o IngressListMapOutput) MapIndex(k pulumi.StringInput) IngressListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressList { return vs[0].(map[string]*IngressList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/ingressPatch.go b/sdk/go/kubernetes/extensions/v1beta1/ingressPatch.go index fabb181f77..be683a7992 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/ingressPatch.go +++ b/sdk/go/kubernetes/extensions/v1beta1/ingressPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -146,6 +147,12 @@ func (i *IngressPatch) ToIngressPatchOutputWithContext(ctx context.Context) Ingr return pulumi.ToOutputWithContext(ctx, i).(IngressPatchOutput) } +func (i *IngressPatch) ToOutput(ctx context.Context) pulumix.Output[*IngressPatch] { + return pulumix.Output[*IngressPatch]{ + OutputState: i.ToIngressPatchOutputWithContext(ctx).OutputState, + } +} + // IngressPatchArrayInput is an input type that accepts IngressPatchArray and IngressPatchArrayOutput values. // You can construct a concrete instance of `IngressPatchArrayInput` via: // @@ -171,6 +178,12 @@ func (i IngressPatchArray) ToIngressPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressPatchArrayOutput) } +func (i IngressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressPatch] { + return pulumix.Output[[]*IngressPatch]{ + OutputState: i.ToIngressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressPatchMapInput is an input type that accepts IngressPatchMap and IngressPatchMapOutput values. // You can construct a concrete instance of `IngressPatchMapInput` via: // @@ -196,6 +209,12 @@ func (i IngressPatchMap) ToIngressPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressPatchMapOutput) } +func (i IngressPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressPatch] { + return pulumix.Output[map[string]*IngressPatch]{ + OutputState: i.ToIngressPatchMapOutputWithContext(ctx).OutputState, + } +} + type IngressPatchOutput struct{ *pulumi.OutputState } func (IngressPatchOutput) ElementType() reflect.Type { @@ -210,6 +229,12 @@ func (o IngressPatchOutput) ToIngressPatchOutputWithContext(ctx context.Context) return o } +func (o IngressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressPatch] { + return pulumix.Output[*IngressPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *IngressPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -249,6 +274,12 @@ func (o IngressPatchArrayOutput) ToIngressPatchArrayOutputWithContext(ctx contex return o } +func (o IngressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressPatch] { + return pulumix.Output[[]*IngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPatchArrayOutput) Index(i pulumi.IntInput) IngressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressPatch { return vs[0].([]*IngressPatch)[vs[1].(int)] @@ -269,6 +300,12 @@ func (o IngressPatchMapOutput) ToIngressPatchMapOutputWithContext(ctx context.Co return o } +func (o IngressPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressPatch] { + return pulumix.Output[map[string]*IngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPatchMapOutput) MapIndex(k pulumi.StringInput) IngressPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressPatch { return vs[0].(map[string]*IngressPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/networkPolicy.go b/sdk/go/kubernetes/extensions/v1beta1/networkPolicy.go index 55672ef5a9..41b4550272 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/networkPolicy.go +++ b/sdk/go/kubernetes/extensions/v1beta1/networkPolicy.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DEPRECATED 1.9 - This group version of NetworkPolicy is deprecated by networking/v1/NetworkPolicy. NetworkPolicy describes what network traffic is allowed for a set of Pods @@ -119,6 +120,12 @@ func (i *NetworkPolicy) ToNetworkPolicyOutputWithContext(ctx context.Context) Ne return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyOutput) } +func (i *NetworkPolicy) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicy] { + return pulumix.Output[*NetworkPolicy]{ + OutputState: i.ToNetworkPolicyOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyArrayInput is an input type that accepts NetworkPolicyArray and NetworkPolicyArrayOutput values. // You can construct a concrete instance of `NetworkPolicyArrayInput` via: // @@ -144,6 +151,12 @@ func (i NetworkPolicyArray) ToNetworkPolicyArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyArrayOutput) } +func (i NetworkPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicy] { + return pulumix.Output[[]*NetworkPolicy]{ + OutputState: i.ToNetworkPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyMapInput is an input type that accepts NetworkPolicyMap and NetworkPolicyMapOutput values. // You can construct a concrete instance of `NetworkPolicyMapInput` via: // @@ -169,6 +182,12 @@ func (i NetworkPolicyMap) ToNetworkPolicyMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyMapOutput) } +func (i NetworkPolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicy] { + return pulumix.Output[map[string]*NetworkPolicy]{ + OutputState: i.ToNetworkPolicyMapOutputWithContext(ctx).OutputState, + } +} + type NetworkPolicyOutput struct{ *pulumi.OutputState } func (NetworkPolicyOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o NetworkPolicyOutput) ToNetworkPolicyOutputWithContext(ctx context.Contex return o } +func (o NetworkPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicy] { + return pulumix.Output[*NetworkPolicy]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *NetworkPolicy) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o NetworkPolicyArrayOutput) ToNetworkPolicyArrayOutputWithContext(ctx cont return o } +func (o NetworkPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicy] { + return pulumix.Output[[]*NetworkPolicy]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyArrayOutput) Index(i pulumi.IntInput) NetworkPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkPolicy { return vs[0].([]*NetworkPolicy)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o NetworkPolicyMapOutput) ToNetworkPolicyMapOutputWithContext(ctx context. return o } +func (o NetworkPolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicy] { + return pulumix.Output[map[string]*NetworkPolicy]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyMapOutput) MapIndex(k pulumi.StringInput) NetworkPolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkPolicy { return vs[0].(map[string]*NetworkPolicy)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/networkPolicyList.go b/sdk/go/kubernetes/extensions/v1beta1/networkPolicyList.go index 5710a81735..ba1c79b202 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/networkPolicyList.go +++ b/sdk/go/kubernetes/extensions/v1beta1/networkPolicyList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DEPRECATED 1.9 - This group version of NetworkPolicyList is deprecated by networking/v1/NetworkPolicyList. Network Policy List is a list of NetworkPolicy objects. @@ -117,6 +118,12 @@ func (i *NetworkPolicyList) ToNetworkPolicyListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListOutput) } +func (i *NetworkPolicyList) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyList] { + return pulumix.Output[*NetworkPolicyList]{ + OutputState: i.ToNetworkPolicyListOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyListArrayInput is an input type that accepts NetworkPolicyListArray and NetworkPolicyListArrayOutput values. // You can construct a concrete instance of `NetworkPolicyListArrayInput` via: // @@ -142,6 +149,12 @@ func (i NetworkPolicyListArray) ToNetworkPolicyListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListArrayOutput) } +func (i NetworkPolicyListArray) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyList] { + return pulumix.Output[[]*NetworkPolicyList]{ + OutputState: i.ToNetworkPolicyListArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyListMapInput is an input type that accepts NetworkPolicyListMap and NetworkPolicyListMapOutput values. // You can construct a concrete instance of `NetworkPolicyListMapInput` via: // @@ -167,6 +180,12 @@ func (i NetworkPolicyListMap) ToNetworkPolicyListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListMapOutput) } +func (i NetworkPolicyListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyList] { + return pulumix.Output[map[string]*NetworkPolicyList]{ + OutputState: i.ToNetworkPolicyListMapOutputWithContext(ctx).OutputState, + } +} + type NetworkPolicyListOutput struct{ *pulumi.OutputState } func (NetworkPolicyListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o NetworkPolicyListOutput) ToNetworkPolicyListOutputWithContext(ctx contex return o } +func (o NetworkPolicyListOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyList] { + return pulumix.Output[*NetworkPolicyList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *NetworkPolicyList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o NetworkPolicyListArrayOutput) ToNetworkPolicyListArrayOutputWithContext( return o } +func (o NetworkPolicyListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyList] { + return pulumix.Output[[]*NetworkPolicyList]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyListArrayOutput) Index(i pulumi.IntInput) NetworkPolicyListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkPolicyList { return vs[0].([]*NetworkPolicyList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o NetworkPolicyListMapOutput) ToNetworkPolicyListMapOutputWithContext(ctx return o } +func (o NetworkPolicyListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyList] { + return pulumix.Output[map[string]*NetworkPolicyList]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyListMapOutput) MapIndex(k pulumi.StringInput) NetworkPolicyListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkPolicyList { return vs[0].(map[string]*NetworkPolicyList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/networkPolicyPatch.go b/sdk/go/kubernetes/extensions/v1beta1/networkPolicyPatch.go index c8903aa323..b2dc432eb2 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/networkPolicyPatch.go +++ b/sdk/go/kubernetes/extensions/v1beta1/networkPolicyPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *NetworkPolicyPatch) ToNetworkPolicyPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchOutput) } +func (i *NetworkPolicyPatch) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyPatch] { + return pulumix.Output[*NetworkPolicyPatch]{ + OutputState: i.ToNetworkPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPatchArrayInput is an input type that accepts NetworkPolicyPatchArray and NetworkPolicyPatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i NetworkPolicyPatchArray) ToNetworkPolicyPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchArrayOutput) } +func (i NetworkPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyPatch] { + return pulumix.Output[[]*NetworkPolicyPatch]{ + OutputState: i.ToNetworkPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPatchMapInput is an input type that accepts NetworkPolicyPatchMap and NetworkPolicyPatchMapOutput values. // You can construct a concrete instance of `NetworkPolicyPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i NetworkPolicyPatchMap) ToNetworkPolicyPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchMapOutput) } +func (i NetworkPolicyPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyPatch] { + return pulumix.Output[map[string]*NetworkPolicyPatch]{ + OutputState: i.ToNetworkPolicyPatchMapOutputWithContext(ctx).OutputState, + } +} + type NetworkPolicyPatchOutput struct{ *pulumi.OutputState } func (NetworkPolicyPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o NetworkPolicyPatchOutput) ToNetworkPolicyPatchOutputWithContext(ctx cont return o } +func (o NetworkPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyPatch] { + return pulumix.Output[*NetworkPolicyPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *NetworkPolicyPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o NetworkPolicyPatchArrayOutput) ToNetworkPolicyPatchArrayOutputWithContex return o } +func (o NetworkPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyPatch] { + return pulumix.Output[[]*NetworkPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkPolicyPatch { return vs[0].([]*NetworkPolicyPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o NetworkPolicyPatchMapOutput) ToNetworkPolicyPatchMapOutputWithContext(ct return o } +func (o NetworkPolicyPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyPatch] { + return pulumix.Output[map[string]*NetworkPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPatchMapOutput) MapIndex(k pulumi.StringInput) NetworkPolicyPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkPolicyPatch { return vs[0].(map[string]*NetworkPolicyPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicy.go b/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicy.go index b14fb01b5b..29c79ac39d 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicy.go +++ b/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicy.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. Deprecated: use PodSecurityPolicy from policy API Group instead. @@ -119,6 +120,12 @@ func (i *PodSecurityPolicy) ToPodSecurityPolicyOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyOutput) } +func (i *PodSecurityPolicy) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicy] { + return pulumix.Output[*PodSecurityPolicy]{ + OutputState: i.ToPodSecurityPolicyOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyArrayInput is an input type that accepts PodSecurityPolicyArray and PodSecurityPolicyArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyArrayInput` via: // @@ -144,6 +151,12 @@ func (i PodSecurityPolicyArray) ToPodSecurityPolicyArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyArrayOutput) } +func (i PodSecurityPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicy] { + return pulumix.Output[[]*PodSecurityPolicy]{ + OutputState: i.ToPodSecurityPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyMapInput is an input type that accepts PodSecurityPolicyMap and PodSecurityPolicyMapOutput values. // You can construct a concrete instance of `PodSecurityPolicyMapInput` via: // @@ -169,6 +182,12 @@ func (i PodSecurityPolicyMap) ToPodSecurityPolicyMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyMapOutput) } +func (i PodSecurityPolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicy] { + return pulumix.Output[map[string]*PodSecurityPolicy]{ + OutputState: i.ToPodSecurityPolicyMapOutputWithContext(ctx).OutputState, + } +} + type PodSecurityPolicyOutput struct{ *pulumi.OutputState } func (PodSecurityPolicyOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o PodSecurityPolicyOutput) ToPodSecurityPolicyOutputWithContext(ctx contex return o } +func (o PodSecurityPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicy] { + return pulumix.Output[*PodSecurityPolicy]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSecurityPolicy) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o PodSecurityPolicyArrayOutput) ToPodSecurityPolicyArrayOutputWithContext( return o } +func (o PodSecurityPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicy] { + return pulumix.Output[[]*PodSecurityPolicy]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSecurityPolicy { return vs[0].([]*PodSecurityPolicy)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o PodSecurityPolicyMapOutput) ToPodSecurityPolicyMapOutputWithContext(ctx return o } +func (o PodSecurityPolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicy] { + return pulumix.Output[map[string]*PodSecurityPolicy]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyMapOutput) MapIndex(k pulumi.StringInput) PodSecurityPolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSecurityPolicy { return vs[0].(map[string]*PodSecurityPolicy)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyList.go b/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyList.go index 0589d800c3..43fc49bc62 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyList.go +++ b/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSecurityPolicyList is a list of PodSecurityPolicy objects. Deprecated: use PodSecurityPolicyList from policy API Group instead. @@ -117,6 +118,12 @@ func (i *PodSecurityPolicyList) ToPodSecurityPolicyListOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListOutput) } +func (i *PodSecurityPolicyList) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyList] { + return pulumix.Output[*PodSecurityPolicyList]{ + OutputState: i.ToPodSecurityPolicyListOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyListArrayInput is an input type that accepts PodSecurityPolicyListArray and PodSecurityPolicyListArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodSecurityPolicyListArray) ToPodSecurityPolicyListArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListArrayOutput) } +func (i PodSecurityPolicyListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyList] { + return pulumix.Output[[]*PodSecurityPolicyList]{ + OutputState: i.ToPodSecurityPolicyListArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyListMapInput is an input type that accepts PodSecurityPolicyListMap and PodSecurityPolicyListMapOutput values. // You can construct a concrete instance of `PodSecurityPolicyListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodSecurityPolicyListMap) ToPodSecurityPolicyListMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListMapOutput) } +func (i PodSecurityPolicyListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyList] { + return pulumix.Output[map[string]*PodSecurityPolicyList]{ + OutputState: i.ToPodSecurityPolicyListMapOutputWithContext(ctx).OutputState, + } +} + type PodSecurityPolicyListOutput struct{ *pulumi.OutputState } func (PodSecurityPolicyListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodSecurityPolicyListOutput) ToPodSecurityPolicyListOutputWithContext(ct return o } +func (o PodSecurityPolicyListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyList] { + return pulumix.Output[*PodSecurityPolicyList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSecurityPolicyList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodSecurityPolicyListArrayOutput) ToPodSecurityPolicyListArrayOutputWith return o } +func (o PodSecurityPolicyListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyList] { + return pulumix.Output[[]*PodSecurityPolicyList]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyListArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSecurityPolicyList { return vs[0].([]*PodSecurityPolicyList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodSecurityPolicyListMapOutput) ToPodSecurityPolicyListMapOutputWithCont return o } +func (o PodSecurityPolicyListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyList] { + return pulumix.Output[map[string]*PodSecurityPolicyList]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyListMapOutput) MapIndex(k pulumi.StringInput) PodSecurityPolicyListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSecurityPolicyList { return vs[0].(map[string]*PodSecurityPolicyList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyPatch.go b/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyPatch.go index b3208d5ed6..89049b30fd 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyPatch.go +++ b/sdk/go/kubernetes/extensions/v1beta1/podSecurityPolicyPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *PodSecurityPolicyPatch) ToPodSecurityPolicyPatchOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchOutput) } +func (i *PodSecurityPolicyPatch) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyPatch] { + return pulumix.Output[*PodSecurityPolicyPatch]{ + OutputState: i.ToPodSecurityPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyPatchArrayInput is an input type that accepts PodSecurityPolicyPatchArray and PodSecurityPolicyPatchArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i PodSecurityPolicyPatchArray) ToPodSecurityPolicyPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchArrayOutput) } +func (i PodSecurityPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyPatch] { + return pulumix.Output[[]*PodSecurityPolicyPatch]{ + OutputState: i.ToPodSecurityPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyPatchMapInput is an input type that accepts PodSecurityPolicyPatchMap and PodSecurityPolicyPatchMapOutput values. // You can construct a concrete instance of `PodSecurityPolicyPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i PodSecurityPolicyPatchMap) ToPodSecurityPolicyPatchMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchMapOutput) } +func (i PodSecurityPolicyPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyPatch] { + return pulumix.Output[map[string]*PodSecurityPolicyPatch]{ + OutputState: i.ToPodSecurityPolicyPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodSecurityPolicyPatchOutput struct{ *pulumi.OutputState } func (PodSecurityPolicyPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o PodSecurityPolicyPatchOutput) ToPodSecurityPolicyPatchOutputWithContext( return o } +func (o PodSecurityPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyPatch] { + return pulumix.Output[*PodSecurityPolicyPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodSecurityPolicyPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o PodSecurityPolicyPatchArrayOutput) ToPodSecurityPolicyPatchArrayOutputWi return o } +func (o PodSecurityPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyPatch] { + return pulumix.Output[[]*PodSecurityPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyPatchArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSecurityPolicyPatch { return vs[0].([]*PodSecurityPolicyPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o PodSecurityPolicyPatchMapOutput) ToPodSecurityPolicyPatchMapOutputWithCo return o } +func (o PodSecurityPolicyPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyPatch] { + return pulumix.Output[map[string]*PodSecurityPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyPatchMapOutput) MapIndex(k pulumi.StringInput) PodSecurityPolicyPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSecurityPolicyPatch { return vs[0].(map[string]*PodSecurityPolicyPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/extensions/v1beta1/pulumiTypes.go index 42563853e7..da6a40c0b5 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/extensions/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -50,6 +51,12 @@ func (i AllowedCSIDriverArgs) ToAllowedCSIDriverOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverOutput) } +func (i AllowedCSIDriverArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriver] { + return pulumix.Output[AllowedCSIDriver]{ + OutputState: i.ToAllowedCSIDriverOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriverArrayInput is an input type that accepts AllowedCSIDriverArray and AllowedCSIDriverArrayOutput values. // You can construct a concrete instance of `AllowedCSIDriverArrayInput` via: // @@ -75,6 +82,12 @@ func (i AllowedCSIDriverArray) ToAllowedCSIDriverArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverArrayOutput) } +func (i AllowedCSIDriverArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriver] { + return pulumix.Output[[]AllowedCSIDriver]{ + OutputState: i.ToAllowedCSIDriverArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriver represents a single inline CSI Driver that is allowed to be used. type AllowedCSIDriverOutput struct{ *pulumi.OutputState } @@ -90,6 +103,12 @@ func (o AllowedCSIDriverOutput) ToAllowedCSIDriverOutputWithContext(ctx context. return o } +func (o AllowedCSIDriverOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriver] { + return pulumix.Output[AllowedCSIDriver]{ + OutputState: o.OutputState, + } +} + // Name is the registered name of the CSI driver func (o AllowedCSIDriverOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v AllowedCSIDriver) string { return v.Name }).(pulumi.StringOutput) @@ -109,6 +128,12 @@ func (o AllowedCSIDriverArrayOutput) ToAllowedCSIDriverArrayOutputWithContext(ct return o } +func (o AllowedCSIDriverArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriver] { + return pulumix.Output[[]AllowedCSIDriver]{ + OutputState: o.OutputState, + } +} + func (o AllowedCSIDriverArrayOutput) Index(i pulumi.IntInput) AllowedCSIDriverOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedCSIDriver { return vs[0].([]AllowedCSIDriver)[vs[1].(int)] @@ -150,6 +175,12 @@ func (i AllowedCSIDriverPatchArgs) ToAllowedCSIDriverPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverPatchOutput) } +func (i AllowedCSIDriverPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriverPatch] { + return pulumix.Output[AllowedCSIDriverPatch]{ + OutputState: i.ToAllowedCSIDriverPatchOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriverPatchArrayInput is an input type that accepts AllowedCSIDriverPatchArray and AllowedCSIDriverPatchArrayOutput values. // You can construct a concrete instance of `AllowedCSIDriverPatchArrayInput` via: // @@ -175,6 +206,12 @@ func (i AllowedCSIDriverPatchArray) ToAllowedCSIDriverPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverPatchArrayOutput) } +func (i AllowedCSIDriverPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriverPatch] { + return pulumix.Output[[]AllowedCSIDriverPatch]{ + OutputState: i.ToAllowedCSIDriverPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriver represents a single inline CSI Driver that is allowed to be used. type AllowedCSIDriverPatchOutput struct{ *pulumi.OutputState } @@ -190,6 +227,12 @@ func (o AllowedCSIDriverPatchOutput) ToAllowedCSIDriverPatchOutputWithContext(ct return o } +func (o AllowedCSIDriverPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriverPatch] { + return pulumix.Output[AllowedCSIDriverPatch]{ + OutputState: o.OutputState, + } +} + // Name is the registered name of the CSI driver func (o AllowedCSIDriverPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v AllowedCSIDriverPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -209,6 +252,12 @@ func (o AllowedCSIDriverPatchArrayOutput) ToAllowedCSIDriverPatchArrayOutputWith return o } +func (o AllowedCSIDriverPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriverPatch] { + return pulumix.Output[[]AllowedCSIDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o AllowedCSIDriverPatchArrayOutput) Index(i pulumi.IntInput) AllowedCSIDriverPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedCSIDriverPatch { return vs[0].([]AllowedCSIDriverPatch)[vs[1].(int)] @@ -250,6 +299,12 @@ func (i AllowedFlexVolumeArgs) ToAllowedFlexVolumeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumeOutput) } +func (i AllowedFlexVolumeArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolume] { + return pulumix.Output[AllowedFlexVolume]{ + OutputState: i.ToAllowedFlexVolumeOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolumeArrayInput is an input type that accepts AllowedFlexVolumeArray and AllowedFlexVolumeArrayOutput values. // You can construct a concrete instance of `AllowedFlexVolumeArrayInput` via: // @@ -275,6 +330,12 @@ func (i AllowedFlexVolumeArray) ToAllowedFlexVolumeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumeArrayOutput) } +func (i AllowedFlexVolumeArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolume] { + return pulumix.Output[[]AllowedFlexVolume]{ + OutputState: i.ToAllowedFlexVolumeArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolume represents a single Flexvolume that is allowed to be used. Deprecated: use AllowedFlexVolume from policy API Group instead. type AllowedFlexVolumeOutput struct{ *pulumi.OutputState } @@ -290,6 +351,12 @@ func (o AllowedFlexVolumeOutput) ToAllowedFlexVolumeOutputWithContext(ctx contex return o } +func (o AllowedFlexVolumeOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolume] { + return pulumix.Output[AllowedFlexVolume]{ + OutputState: o.OutputState, + } +} + // driver is the name of the Flexvolume driver. func (o AllowedFlexVolumeOutput) Driver() pulumi.StringOutput { return o.ApplyT(func(v AllowedFlexVolume) string { return v.Driver }).(pulumi.StringOutput) @@ -309,6 +376,12 @@ func (o AllowedFlexVolumeArrayOutput) ToAllowedFlexVolumeArrayOutputWithContext( return o } +func (o AllowedFlexVolumeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolume] { + return pulumix.Output[[]AllowedFlexVolume]{ + OutputState: o.OutputState, + } +} + func (o AllowedFlexVolumeArrayOutput) Index(i pulumi.IntInput) AllowedFlexVolumeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedFlexVolume { return vs[0].([]AllowedFlexVolume)[vs[1].(int)] @@ -350,6 +423,12 @@ func (i AllowedFlexVolumePatchArgs) ToAllowedFlexVolumePatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumePatchOutput) } +func (i AllowedFlexVolumePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolumePatch] { + return pulumix.Output[AllowedFlexVolumePatch]{ + OutputState: i.ToAllowedFlexVolumePatchOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolumePatchArrayInput is an input type that accepts AllowedFlexVolumePatchArray and AllowedFlexVolumePatchArrayOutput values. // You can construct a concrete instance of `AllowedFlexVolumePatchArrayInput` via: // @@ -375,6 +454,12 @@ func (i AllowedFlexVolumePatchArray) ToAllowedFlexVolumePatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumePatchArrayOutput) } +func (i AllowedFlexVolumePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolumePatch] { + return pulumix.Output[[]AllowedFlexVolumePatch]{ + OutputState: i.ToAllowedFlexVolumePatchArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolume represents a single Flexvolume that is allowed to be used. Deprecated: use AllowedFlexVolume from policy API Group instead. type AllowedFlexVolumePatchOutput struct{ *pulumi.OutputState } @@ -390,6 +475,12 @@ func (o AllowedFlexVolumePatchOutput) ToAllowedFlexVolumePatchOutputWithContext( return o } +func (o AllowedFlexVolumePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolumePatch] { + return pulumix.Output[AllowedFlexVolumePatch]{ + OutputState: o.OutputState, + } +} + // driver is the name of the Flexvolume driver. func (o AllowedFlexVolumePatchOutput) Driver() pulumi.StringPtrOutput { return o.ApplyT(func(v AllowedFlexVolumePatch) *string { return v.Driver }).(pulumi.StringPtrOutput) @@ -409,6 +500,12 @@ func (o AllowedFlexVolumePatchArrayOutput) ToAllowedFlexVolumePatchArrayOutputWi return o } +func (o AllowedFlexVolumePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolumePatch] { + return pulumix.Output[[]AllowedFlexVolumePatch]{ + OutputState: o.OutputState, + } +} + func (o AllowedFlexVolumePatchArrayOutput) Index(i pulumi.IntInput) AllowedFlexVolumePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedFlexVolumePatch { return vs[0].([]AllowedFlexVolumePatch)[vs[1].(int)] @@ -458,6 +555,12 @@ func (i AllowedHostPathArgs) ToAllowedHostPathOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathOutput) } +func (i AllowedHostPathArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPath] { + return pulumix.Output[AllowedHostPath]{ + OutputState: i.ToAllowedHostPathOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPathArrayInput is an input type that accepts AllowedHostPathArray and AllowedHostPathArrayOutput values. // You can construct a concrete instance of `AllowedHostPathArrayInput` via: // @@ -483,6 +586,12 @@ func (i AllowedHostPathArray) ToAllowedHostPathArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathArrayOutput) } +func (i AllowedHostPathArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPath] { + return pulumix.Output[[]AllowedHostPath]{ + OutputState: i.ToAllowedHostPathArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. Deprecated: use AllowedHostPath from policy API Group instead. type AllowedHostPathOutput struct{ *pulumi.OutputState } @@ -498,6 +607,12 @@ func (o AllowedHostPathOutput) ToAllowedHostPathOutputWithContext(ctx context.Co return o } +func (o AllowedHostPathOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPath] { + return pulumix.Output[AllowedHostPath]{ + OutputState: o.OutputState, + } +} + // pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. // // Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` @@ -524,6 +639,12 @@ func (o AllowedHostPathArrayOutput) ToAllowedHostPathArrayOutputWithContext(ctx return o } +func (o AllowedHostPathArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPath] { + return pulumix.Output[[]AllowedHostPath]{ + OutputState: o.OutputState, + } +} + func (o AllowedHostPathArrayOutput) Index(i pulumi.IntInput) AllowedHostPathOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedHostPath { return vs[0].([]AllowedHostPath)[vs[1].(int)] @@ -573,6 +694,12 @@ func (i AllowedHostPathPatchArgs) ToAllowedHostPathPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathPatchOutput) } +func (i AllowedHostPathPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPathPatch] { + return pulumix.Output[AllowedHostPathPatch]{ + OutputState: i.ToAllowedHostPathPatchOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPathPatchArrayInput is an input type that accepts AllowedHostPathPatchArray and AllowedHostPathPatchArrayOutput values. // You can construct a concrete instance of `AllowedHostPathPatchArrayInput` via: // @@ -598,6 +725,12 @@ func (i AllowedHostPathPatchArray) ToAllowedHostPathPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathPatchArrayOutput) } +func (i AllowedHostPathPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPathPatch] { + return pulumix.Output[[]AllowedHostPathPatch]{ + OutputState: i.ToAllowedHostPathPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. Deprecated: use AllowedHostPath from policy API Group instead. type AllowedHostPathPatchOutput struct{ *pulumi.OutputState } @@ -613,6 +746,12 @@ func (o AllowedHostPathPatchOutput) ToAllowedHostPathPatchOutputWithContext(ctx return o } +func (o AllowedHostPathPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPathPatch] { + return pulumix.Output[AllowedHostPathPatch]{ + OutputState: o.OutputState, + } +} + // pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. // // Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` @@ -639,6 +778,12 @@ func (o AllowedHostPathPatchArrayOutput) ToAllowedHostPathPatchArrayOutputWithCo return o } +func (o AllowedHostPathPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPathPatch] { + return pulumix.Output[[]AllowedHostPathPatch]{ + OutputState: o.OutputState, + } +} + func (o AllowedHostPathPatchArrayOutput) Index(i pulumi.IntInput) AllowedHostPathPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedHostPathPatch { return vs[0].([]AllowedHostPathPatch)[vs[1].(int)] @@ -696,6 +841,12 @@ func (i DaemonSetTypeArgs) ToDaemonSetTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetTypeOutput) } +func (i DaemonSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetType] { + return pulumix.Output[DaemonSetType]{ + OutputState: i.ToDaemonSetTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSetTypeArrayInput is an input type that accepts DaemonSetTypeArray and DaemonSetTypeArrayOutput values. // You can construct a concrete instance of `DaemonSetTypeArrayInput` via: // @@ -721,6 +872,12 @@ func (i DaemonSetTypeArray) ToDaemonSetTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetTypeArrayOutput) } +func (i DaemonSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetType] { + return pulumix.Output[[]DaemonSetType]{ + OutputState: i.ToDaemonSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSet represents the configuration of a daemon set. type DaemonSetTypeOutput struct{ *pulumi.OutputState } @@ -736,6 +893,12 @@ func (o DaemonSetTypeOutput) ToDaemonSetTypeOutputWithContext(ctx context.Contex return o } +func (o DaemonSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetType] { + return pulumix.Output[DaemonSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -775,6 +938,12 @@ func (o DaemonSetTypeArrayOutput) ToDaemonSetTypeArrayOutputWithContext(ctx cont return o } +func (o DaemonSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetType] { + return pulumix.Output[[]DaemonSetType]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetTypeArrayOutput) Index(i pulumi.IntInput) DaemonSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetType { return vs[0].([]DaemonSetType)[vs[1].(int)] @@ -832,6 +1001,12 @@ func (i DaemonSetConditionArgs) ToDaemonSetConditionOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionOutput) } +func (i DaemonSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetCondition] { + return pulumix.Output[DaemonSetCondition]{ + OutputState: i.ToDaemonSetConditionOutputWithContext(ctx).OutputState, + } +} + // DaemonSetConditionArrayInput is an input type that accepts DaemonSetConditionArray and DaemonSetConditionArrayOutput values. // You can construct a concrete instance of `DaemonSetConditionArrayInput` via: // @@ -857,6 +1032,12 @@ func (i DaemonSetConditionArray) ToDaemonSetConditionArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionArrayOutput) } +func (i DaemonSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetCondition] { + return pulumix.Output[[]DaemonSetCondition]{ + OutputState: i.ToDaemonSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetCondition describes the state of a DaemonSet at a certain point. type DaemonSetConditionOutput struct{ *pulumi.OutputState } @@ -872,6 +1053,12 @@ func (o DaemonSetConditionOutput) ToDaemonSetConditionOutputWithContext(ctx cont return o } +func (o DaemonSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetCondition] { + return pulumix.Output[DaemonSetCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DaemonSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -911,6 +1098,12 @@ func (o DaemonSetConditionArrayOutput) ToDaemonSetConditionArrayOutputWithContex return o } +func (o DaemonSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetCondition] { + return pulumix.Output[[]DaemonSetCondition]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetConditionArrayOutput) Index(i pulumi.IntInput) DaemonSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetCondition { return vs[0].([]DaemonSetCondition)[vs[1].(int)] @@ -968,6 +1161,12 @@ func (i DaemonSetConditionPatchArgs) ToDaemonSetConditionPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionPatchOutput) } +func (i DaemonSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetConditionPatch] { + return pulumix.Output[DaemonSetConditionPatch]{ + OutputState: i.ToDaemonSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DaemonSetConditionPatchArrayInput is an input type that accepts DaemonSetConditionPatchArray and DaemonSetConditionPatchArrayOutput values. // You can construct a concrete instance of `DaemonSetConditionPatchArrayInput` via: // @@ -993,6 +1192,12 @@ func (i DaemonSetConditionPatchArray) ToDaemonSetConditionPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(DaemonSetConditionPatchArrayOutput) } +func (i DaemonSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetConditionPatch] { + return pulumix.Output[[]DaemonSetConditionPatch]{ + OutputState: i.ToDaemonSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DaemonSetCondition describes the state of a DaemonSet at a certain point. type DaemonSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -1008,6 +1213,12 @@ func (o DaemonSetConditionPatchOutput) ToDaemonSetConditionPatchOutputWithContex return o } +func (o DaemonSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetConditionPatch] { + return pulumix.Output[DaemonSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DaemonSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -1047,6 +1258,12 @@ func (o DaemonSetConditionPatchArrayOutput) ToDaemonSetConditionPatchArrayOutput return o } +func (o DaemonSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DaemonSetConditionPatch] { + return pulumix.Output[[]DaemonSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetConditionPatchArrayOutput) Index(i pulumi.IntInput) DaemonSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DaemonSetConditionPatch { return vs[0].([]DaemonSetConditionPatch)[vs[1].(int)] @@ -1100,6 +1317,12 @@ func (i DaemonSetListTypeArgs) ToDaemonSetListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DaemonSetListTypeOutput) } +func (i DaemonSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetListType] { + return pulumix.Output[DaemonSetListType]{ + OutputState: i.ToDaemonSetListTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSetList is a collection of daemon sets. type DaemonSetListTypeOutput struct{ *pulumi.OutputState } @@ -1115,6 +1338,12 @@ func (o DaemonSetListTypeOutput) ToDaemonSetListTypeOutputWithContext(ctx contex return o } +func (o DaemonSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetListType] { + return pulumix.Output[DaemonSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1186,6 +1415,12 @@ func (i DaemonSetPatchTypeArgs) ToDaemonSetPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetPatchTypeOutput) } +func (i DaemonSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetPatchType] { + return pulumix.Output[DaemonSetPatchType]{ + OutputState: i.ToDaemonSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // DaemonSet represents the configuration of a daemon set. type DaemonSetPatchTypeOutput struct{ *pulumi.OutputState } @@ -1201,6 +1436,12 @@ func (o DaemonSetPatchTypeOutput) ToDaemonSetPatchTypeOutputWithContext(ctx cont return o } +func (o DaemonSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetPatchType] { + return pulumix.Output[DaemonSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DaemonSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DaemonSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1281,6 +1522,12 @@ func (i DaemonSetSpecArgs) ToDaemonSetSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecOutput) } +func (i DaemonSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpec] { + return pulumix.Output[DaemonSetSpec]{ + OutputState: i.ToDaemonSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetSpecArgs) ToDaemonSetSpecPtrOutput() DaemonSetSpecPtrOutput { return i.ToDaemonSetSpecPtrOutputWithContext(context.Background()) } @@ -1322,6 +1569,12 @@ func (i *daemonSetSpecPtrType) ToDaemonSetSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPtrOutput) } +func (i *daemonSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpec] { + return pulumix.Output[*DaemonSetSpec]{ + OutputState: i.ToDaemonSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetSpec is the specification of a daemon set. type DaemonSetSpecOutput struct{ *pulumi.OutputState } @@ -1347,6 +1600,12 @@ func (o DaemonSetSpecOutput) ToDaemonSetSpecPtrOutputWithContext(ctx context.Con }).(DaemonSetSpecPtrOutput) } +func (o DaemonSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpec] { + return pulumix.Output[DaemonSetSpec]{ + OutputState: o.OutputState, + } +} + // The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). func (o DaemonSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1391,6 +1650,12 @@ func (o DaemonSetSpecPtrOutput) ToDaemonSetSpecPtrOutputWithContext(ctx context. return o } +func (o DaemonSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpec] { + return pulumix.Output[*DaemonSetSpec]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetSpecPtrOutput) Elem() DaemonSetSpecOutput { return o.ApplyT(func(v *DaemonSetSpec) DaemonSetSpec { if v != nil { @@ -1516,6 +1781,12 @@ func (i DaemonSetSpecPatchArgs) ToDaemonSetSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPatchOutput) } +func (i DaemonSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpecPatch] { + return pulumix.Output[DaemonSetSpecPatch]{ + OutputState: i.ToDaemonSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetSpecPatchArgs) ToDaemonSetSpecPatchPtrOutput() DaemonSetSpecPatchPtrOutput { return i.ToDaemonSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -1557,6 +1828,12 @@ func (i *daemonSetSpecPatchPtrType) ToDaemonSetSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DaemonSetSpecPatchPtrOutput) } +func (i *daemonSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpecPatch] { + return pulumix.Output[*DaemonSetSpecPatch]{ + OutputState: i.ToDaemonSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetSpec is the specification of a daemon set. type DaemonSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -1582,6 +1859,12 @@ func (o DaemonSetSpecPatchOutput) ToDaemonSetSpecPatchPtrOutputWithContext(ctx c }).(DaemonSetSpecPatchPtrOutput) } +func (o DaemonSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetSpecPatch] { + return pulumix.Output[DaemonSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). func (o DaemonSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -1626,6 +1909,12 @@ func (o DaemonSetSpecPatchPtrOutput) ToDaemonSetSpecPatchPtrOutputWithContext(ct return o } +func (o DaemonSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetSpecPatch] { + return pulumix.Output[*DaemonSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetSpecPatchPtrOutput) Elem() DaemonSetSpecPatchOutput { return o.ApplyT(func(v *DaemonSetSpecPatch) DaemonSetSpecPatch { if v != nil { @@ -1767,6 +2056,12 @@ func (i DaemonSetStatusArgs) ToDaemonSetStatusOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusOutput) } +func (i DaemonSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatus] { + return pulumix.Output[DaemonSetStatus]{ + OutputState: i.ToDaemonSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetStatusArgs) ToDaemonSetStatusPtrOutput() DaemonSetStatusPtrOutput { return i.ToDaemonSetStatusPtrOutputWithContext(context.Background()) } @@ -1808,6 +2103,12 @@ func (i *daemonSetStatusPtrType) ToDaemonSetStatusPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPtrOutput) } +func (i *daemonSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatus] { + return pulumix.Output[*DaemonSetStatus]{ + OutputState: i.ToDaemonSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetStatus represents the current status of a daemon set. type DaemonSetStatusOutput struct{ *pulumi.OutputState } @@ -1833,6 +2134,12 @@ func (o DaemonSetStatusOutput) ToDaemonSetStatusPtrOutputWithContext(ctx context }).(DaemonSetStatusPtrOutput) } +func (o DaemonSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatus] { + return pulumix.Output[DaemonSetStatus]{ + OutputState: o.OutputState, + } +} + // Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o DaemonSetStatusOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetStatus) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -1897,6 +2204,12 @@ func (o DaemonSetStatusPtrOutput) ToDaemonSetStatusPtrOutputWithContext(ctx cont return o } +func (o DaemonSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatus] { + return pulumix.Output[*DaemonSetStatus]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetStatusPtrOutput) Elem() DaemonSetStatusOutput { return o.ApplyT(func(v *DaemonSetStatus) DaemonSetStatus { if v != nil { @@ -2078,6 +2391,12 @@ func (i DaemonSetStatusPatchArgs) ToDaemonSetStatusPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPatchOutput) } +func (i DaemonSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatusPatch] { + return pulumix.Output[DaemonSetStatusPatch]{ + OutputState: i.ToDaemonSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetStatusPatchArgs) ToDaemonSetStatusPatchPtrOutput() DaemonSetStatusPatchPtrOutput { return i.ToDaemonSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -2119,6 +2438,12 @@ func (i *daemonSetStatusPatchPtrType) ToDaemonSetStatusPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(DaemonSetStatusPatchPtrOutput) } +func (i *daemonSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatusPatch] { + return pulumix.Output[*DaemonSetStatusPatch]{ + OutputState: i.ToDaemonSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DaemonSetStatus represents the current status of a daemon set. type DaemonSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -2144,6 +2469,12 @@ func (o DaemonSetStatusPatchOutput) ToDaemonSetStatusPatchPtrOutputWithContext(c }).(DaemonSetStatusPatchPtrOutput) } +func (o DaemonSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetStatusPatch] { + return pulumix.Output[DaemonSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. func (o DaemonSetStatusPatchOutput) CollisionCount() pulumi.IntPtrOutput { return o.ApplyT(func(v DaemonSetStatusPatch) *int { return v.CollisionCount }).(pulumi.IntPtrOutput) @@ -2208,6 +2539,12 @@ func (o DaemonSetStatusPatchPtrOutput) ToDaemonSetStatusPatchPtrOutputWithContex return o } +func (o DaemonSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetStatusPatch] { + return pulumix.Output[*DaemonSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetStatusPatchPtrOutput) Elem() DaemonSetStatusPatchOutput { return o.ApplyT(func(v *DaemonSetStatusPatch) DaemonSetStatusPatch { if v != nil { @@ -2355,6 +2692,12 @@ func (i DaemonSetUpdateStrategyArgs) ToDaemonSetUpdateStrategyOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyOutput) } +func (i DaemonSetUpdateStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategy] { + return pulumix.Output[DaemonSetUpdateStrategy]{ + OutputState: i.ToDaemonSetUpdateStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetUpdateStrategyArgs) ToDaemonSetUpdateStrategyPtrOutput() DaemonSetUpdateStrategyPtrOutput { return i.ToDaemonSetUpdateStrategyPtrOutputWithContext(context.Background()) } @@ -2396,6 +2739,12 @@ func (i *daemonSetUpdateStrategyPtrType) ToDaemonSetUpdateStrategyPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPtrOutput) } +func (i *daemonSetUpdateStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategy] { + return pulumix.Output[*DaemonSetUpdateStrategy]{ + OutputState: i.ToDaemonSetUpdateStrategyPtrOutputWithContext(ctx).OutputState, + } +} + type DaemonSetUpdateStrategyOutput struct{ *pulumi.OutputState } func (DaemonSetUpdateStrategyOutput) ElementType() reflect.Type { @@ -2420,6 +2769,12 @@ func (o DaemonSetUpdateStrategyOutput) ToDaemonSetUpdateStrategyPtrOutputWithCon }).(DaemonSetUpdateStrategyPtrOutput) } +func (o DaemonSetUpdateStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategy] { + return pulumix.Output[DaemonSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if type = "RollingUpdate". func (o DaemonSetUpdateStrategyOutput) RollingUpdate() RollingUpdateDaemonSetPtrOutput { return o.ApplyT(func(v DaemonSetUpdateStrategy) *RollingUpdateDaemonSet { return v.RollingUpdate }).(RollingUpdateDaemonSetPtrOutput) @@ -2444,6 +2799,12 @@ func (o DaemonSetUpdateStrategyPtrOutput) ToDaemonSetUpdateStrategyPtrOutputWith return o } +func (o DaemonSetUpdateStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategy] { + return pulumix.Output[*DaemonSetUpdateStrategy]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetUpdateStrategyPtrOutput) Elem() DaemonSetUpdateStrategyOutput { return o.ApplyT(func(v *DaemonSetUpdateStrategy) DaemonSetUpdateStrategy { if v != nil { @@ -2511,6 +2872,12 @@ func (i DaemonSetUpdateStrategyPatchArgs) ToDaemonSetUpdateStrategyPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPatchOutput) } +func (i DaemonSetUpdateStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategyPatch] { + return pulumix.Output[DaemonSetUpdateStrategyPatch]{ + OutputState: i.ToDaemonSetUpdateStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DaemonSetUpdateStrategyPatchArgs) ToDaemonSetUpdateStrategyPatchPtrOutput() DaemonSetUpdateStrategyPatchPtrOutput { return i.ToDaemonSetUpdateStrategyPatchPtrOutputWithContext(context.Background()) } @@ -2552,6 +2919,12 @@ func (i *daemonSetUpdateStrategyPatchPtrType) ToDaemonSetUpdateStrategyPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(DaemonSetUpdateStrategyPatchPtrOutput) } +func (i *daemonSetUpdateStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategyPatch] { + return pulumix.Output[*DaemonSetUpdateStrategyPatch]{ + OutputState: i.ToDaemonSetUpdateStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + type DaemonSetUpdateStrategyPatchOutput struct{ *pulumi.OutputState } func (DaemonSetUpdateStrategyPatchOutput) ElementType() reflect.Type { @@ -2576,6 +2949,12 @@ func (o DaemonSetUpdateStrategyPatchOutput) ToDaemonSetUpdateStrategyPatchPtrOut }).(DaemonSetUpdateStrategyPatchPtrOutput) } +func (o DaemonSetUpdateStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DaemonSetUpdateStrategyPatch] { + return pulumix.Output[DaemonSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if type = "RollingUpdate". func (o DaemonSetUpdateStrategyPatchOutput) RollingUpdate() RollingUpdateDaemonSetPatchPtrOutput { return o.ApplyT(func(v DaemonSetUpdateStrategyPatch) *RollingUpdateDaemonSetPatch { return v.RollingUpdate }).(RollingUpdateDaemonSetPatchPtrOutput) @@ -2600,6 +2979,12 @@ func (o DaemonSetUpdateStrategyPatchPtrOutput) ToDaemonSetUpdateStrategyPatchPtr return o } +func (o DaemonSetUpdateStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DaemonSetUpdateStrategyPatch] { + return pulumix.Output[*DaemonSetUpdateStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DaemonSetUpdateStrategyPatchPtrOutput) Elem() DaemonSetUpdateStrategyPatchOutput { return o.ApplyT(func(v *DaemonSetUpdateStrategyPatch) DaemonSetUpdateStrategyPatch { if v != nil { @@ -2725,6 +3110,12 @@ func (i DeploymentTypeArgs) ToDeploymentTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeOutput) } +func (i DeploymentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: i.ToDeploymentTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentTypeArrayInput is an input type that accepts DeploymentTypeArray and DeploymentTypeArrayOutput values. // You can construct a concrete instance of `DeploymentTypeArrayInput` via: // @@ -2750,6 +3141,12 @@ func (i DeploymentTypeArray) ToDeploymentTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DeploymentTypeArrayOutput) } +func (i DeploymentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: i.ToDeploymentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -2787,6 +3184,12 @@ func (o DeploymentTypeOutput) ToDeploymentTypeOutputWithContext(ctx context.Cont return o } +func (o DeploymentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentType] { + return pulumix.Output[DeploymentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2826,6 +3229,12 @@ func (o DeploymentTypeArrayOutput) ToDeploymentTypeArrayOutputWithContext(ctx co return o } +func (o DeploymentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentType] { + return pulumix.Output[[]DeploymentType]{ + OutputState: o.OutputState, + } +} + func (o DeploymentTypeArrayOutput) Index(i pulumi.IntInput) DeploymentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentType { return vs[0].([]DeploymentType)[vs[1].(int)] @@ -2887,6 +3296,12 @@ func (i DeploymentConditionArgs) ToDeploymentConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionOutput) } +func (i DeploymentConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: i.ToDeploymentConditionOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionArrayInput is an input type that accepts DeploymentConditionArray and DeploymentConditionArrayOutput values. // You can construct a concrete instance of `DeploymentConditionArrayInput` via: // @@ -2912,6 +3327,12 @@ func (i DeploymentConditionArray) ToDeploymentConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionArrayOutput) } +func (i DeploymentConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: i.ToDeploymentConditionArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionOutput struct{ *pulumi.OutputState } @@ -2927,6 +3348,12 @@ func (o DeploymentConditionOutput) ToDeploymentConditionOutputWithContext(ctx co return o } +func (o DeploymentConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentCondition] { + return pulumix.Output[DeploymentCondition]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -2971,6 +3398,12 @@ func (o DeploymentConditionArrayOutput) ToDeploymentConditionArrayOutputWithCont return o } +func (o DeploymentConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentCondition] { + return pulumix.Output[[]DeploymentCondition]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionArrayOutput) Index(i pulumi.IntInput) DeploymentConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentCondition { return vs[0].([]DeploymentCondition)[vs[1].(int)] @@ -3032,6 +3465,12 @@ func (i DeploymentConditionPatchArgs) ToDeploymentConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchOutput) } +func (i DeploymentConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchOutputWithContext(ctx).OutputState, + } +} + // DeploymentConditionPatchArrayInput is an input type that accepts DeploymentConditionPatchArray and DeploymentConditionPatchArrayOutput values. // You can construct a concrete instance of `DeploymentConditionPatchArrayInput` via: // @@ -3057,6 +3496,12 @@ func (i DeploymentConditionPatchArray) ToDeploymentConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(DeploymentConditionPatchArrayOutput) } +func (i DeploymentConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: i.ToDeploymentConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DeploymentCondition describes the state of a deployment at a certain point. type DeploymentConditionPatchOutput struct{ *pulumi.OutputState } @@ -3072,6 +3517,12 @@ func (o DeploymentConditionPatchOutput) ToDeploymentConditionPatchOutputWithCont return o } +func (o DeploymentConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentConditionPatch] { + return pulumix.Output[DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + // Last time the condition transitioned from one status to another. func (o DeploymentConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3116,6 +3567,12 @@ func (o DeploymentConditionPatchArrayOutput) ToDeploymentConditionPatchArrayOutp return o } +func (o DeploymentConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]DeploymentConditionPatch] { + return pulumix.Output[[]DeploymentConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentConditionPatchArrayOutput) Index(i pulumi.IntInput) DeploymentConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentConditionPatch { return vs[0].([]DeploymentConditionPatch)[vs[1].(int)] @@ -3169,6 +3626,12 @@ func (i DeploymentListTypeArgs) ToDeploymentListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentListTypeOutput) } +func (i DeploymentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: i.ToDeploymentListTypeOutputWithContext(ctx).OutputState, + } +} + // DeploymentList is a list of Deployments. type DeploymentListTypeOutput struct{ *pulumi.OutputState } @@ -3184,6 +3647,12 @@ func (o DeploymentListTypeOutput) ToDeploymentListTypeOutputWithContext(ctx cont return o } +func (o DeploymentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentListType] { + return pulumix.Output[DeploymentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3299,6 +3768,12 @@ func (i DeploymentPatchTypeArgs) ToDeploymentPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentPatchTypeOutput) } +func (i DeploymentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: i.ToDeploymentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Deployment enables declarative updates for Pods and ReplicaSets. // // This resource waits until its status is ready before registering success @@ -3336,6 +3811,12 @@ func (o DeploymentPatchTypeOutput) ToDeploymentPatchTypeOutputWithContext(ctx co return o } +func (o DeploymentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentPatchType] { + return pulumix.Output[DeploymentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3412,6 +3893,12 @@ func (i DeploymentRollbackArgs) ToDeploymentRollbackOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentRollbackOutput) } +func (i DeploymentRollbackArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollback] { + return pulumix.Output[DeploymentRollback]{ + OutputState: i.ToDeploymentRollbackOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. type DeploymentRollbackOutput struct{ *pulumi.OutputState } @@ -3427,6 +3914,12 @@ func (o DeploymentRollbackOutput) ToDeploymentRollbackOutputWithContext(ctx cont return o } +func (o DeploymentRollbackOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollback] { + return pulumix.Output[DeploymentRollback]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentRollbackOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentRollback) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3503,6 +3996,12 @@ func (i DeploymentRollbackPatchArgs) ToDeploymentRollbackPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DeploymentRollbackPatchOutput) } +func (i DeploymentRollbackPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollbackPatch] { + return pulumix.Output[DeploymentRollbackPatch]{ + OutputState: i.ToDeploymentRollbackPatchOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. type DeploymentRollbackPatchOutput struct{ *pulumi.OutputState } @@ -3518,6 +4017,12 @@ func (o DeploymentRollbackPatchOutput) ToDeploymentRollbackPatchOutputWithContex return o } +func (o DeploymentRollbackPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentRollbackPatch] { + return pulumix.Output[DeploymentRollbackPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeploymentRollbackPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeploymentRollbackPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3610,6 +4115,12 @@ func (i DeploymentSpecArgs) ToDeploymentSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecOutput) } +func (i DeploymentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: i.ToDeploymentSpecOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecArgs) ToDeploymentSpecPtrOutput() DeploymentSpecPtrOutput { return i.ToDeploymentSpecPtrOutputWithContext(context.Background()) } @@ -3651,6 +4162,12 @@ func (i *deploymentSpecPtrType) ToDeploymentSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPtrOutput) } +func (i *deploymentSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: i.ToDeploymentSpecPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecOutput struct{ *pulumi.OutputState } @@ -3676,6 +4193,12 @@ func (o DeploymentSpecOutput) ToDeploymentSpecPtrOutputWithContext(ctx context.C }).(DeploymentSpecPtrOutput) } +func (o DeploymentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpec] { + return pulumix.Output[DeploymentSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -3735,6 +4258,12 @@ func (o DeploymentSpecPtrOutput) ToDeploymentSpecPtrOutputWithContext(ctx contex return o } +func (o DeploymentSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpec] { + return pulumix.Output[*DeploymentSpec]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPtrOutput) Elem() DeploymentSpecOutput { return o.ApplyT(func(v *DeploymentSpec) DeploymentSpec { if v != nil { @@ -3902,6 +4431,12 @@ func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchOutput) } +func (i DeploymentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentSpecPatchArgs) ToDeploymentSpecPatchPtrOutput() DeploymentSpecPatchPtrOutput { return i.ToDeploymentSpecPatchPtrOutputWithContext(context.Background()) } @@ -3943,6 +4478,12 @@ func (i *deploymentSpecPatchPtrType) ToDeploymentSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(DeploymentSpecPatchPtrOutput) } +func (i *deploymentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: i.ToDeploymentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentSpec is the specification of the desired behavior of the Deployment. type DeploymentSpecPatchOutput struct{ *pulumi.OutputState } @@ -3968,6 +4509,12 @@ func (o DeploymentSpecPatchOutput) ToDeploymentSpecPatchPtrOutputWithContext(ctx }).(DeploymentSpecPatchPtrOutput) } +func (o DeploymentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentSpecPatch] { + return pulumix.Output[DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o DeploymentSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -4027,6 +4574,12 @@ func (o DeploymentSpecPatchPtrOutput) ToDeploymentSpecPatchPtrOutputWithContext( return o } +func (o DeploymentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentSpecPatch] { + return pulumix.Output[*DeploymentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentSpecPatchPtrOutput) Elem() DeploymentSpecPatchOutput { return o.ApplyT(func(v *DeploymentSpecPatch) DeploymentSpecPatch { if v != nil { @@ -4190,6 +4743,12 @@ func (i DeploymentStatusArgs) ToDeploymentStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusOutput) } +func (i DeploymentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: i.ToDeploymentStatusOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusArgs) ToDeploymentStatusPtrOutput() DeploymentStatusPtrOutput { return i.ToDeploymentStatusPtrOutputWithContext(context.Background()) } @@ -4231,6 +4790,12 @@ func (i *deploymentStatusPtrType) ToDeploymentStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPtrOutput) } +func (i *deploymentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: i.ToDeploymentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusOutput struct{ *pulumi.OutputState } @@ -4256,6 +4821,12 @@ func (o DeploymentStatusOutput) ToDeploymentStatusPtrOutputWithContext(ctx conte }).(DeploymentStatusPtrOutput) } +func (o DeploymentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatus] { + return pulumix.Output[DeploymentStatus]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -4310,6 +4881,12 @@ func (o DeploymentStatusPtrOutput) ToDeploymentStatusPtrOutputWithContext(ctx co return o } +func (o DeploymentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatus] { + return pulumix.Output[*DeploymentStatus]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPtrOutput) Elem() DeploymentStatusOutput { return o.ApplyT(func(v *DeploymentStatus) DeploymentStatus { if v != nil { @@ -4463,6 +5040,12 @@ func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchOutput) } +func (i DeploymentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStatusPatchArgs) ToDeploymentStatusPatchPtrOutput() DeploymentStatusPatchPtrOutput { return i.ToDeploymentStatusPatchPtrOutputWithContext(context.Background()) } @@ -4504,6 +5087,12 @@ func (i *deploymentStatusPatchPtrType) ToDeploymentStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(DeploymentStatusPatchPtrOutput) } +func (i *deploymentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: i.ToDeploymentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStatus is the most recently observed status of the Deployment. type DeploymentStatusPatchOutput struct{ *pulumi.OutputState } @@ -4529,6 +5118,12 @@ func (o DeploymentStatusPatchOutput) ToDeploymentStatusPatchPtrOutputWithContext }).(DeploymentStatusPatchPtrOutput) } +func (o DeploymentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStatusPatch] { + return pulumix.Output[DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. func (o DeploymentStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v DeploymentStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -4583,6 +5178,12 @@ func (o DeploymentStatusPatchPtrOutput) ToDeploymentStatusPatchPtrOutputWithCont return o } +func (o DeploymentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStatusPatch] { + return pulumix.Output[*DeploymentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStatusPatchPtrOutput) Elem() DeploymentStatusPatchOutput { return o.ApplyT(func(v *DeploymentStatusPatch) DeploymentStatusPatch { if v != nil { @@ -4712,6 +5313,12 @@ func (i DeploymentStrategyArgs) ToDeploymentStrategyOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyOutput) } +func (i DeploymentStrategyArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyArgs) ToDeploymentStrategyPtrOutput() DeploymentStrategyPtrOutput { return i.ToDeploymentStrategyPtrOutputWithContext(context.Background()) } @@ -4753,6 +5360,12 @@ func (i *deploymentStrategyPtrType) ToDeploymentStrategyPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPtrOutput) } +func (i *deploymentStrategyPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: i.ToDeploymentStrategyPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyOutput struct{ *pulumi.OutputState } @@ -4778,6 +5391,12 @@ func (o DeploymentStrategyOutput) ToDeploymentStrategyPtrOutputWithContext(ctx c }).(DeploymentStrategyPtrOutput) } +func (o DeploymentStrategyOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategy] { + return pulumix.Output[DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyOutput) RollingUpdate() RollingUpdateDeploymentPtrOutput { return o.ApplyT(func(v DeploymentStrategy) *RollingUpdateDeployment { return v.RollingUpdate }).(RollingUpdateDeploymentPtrOutput) @@ -4802,6 +5421,12 @@ func (o DeploymentStrategyPtrOutput) ToDeploymentStrategyPtrOutputWithContext(ct return o } +func (o DeploymentStrategyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategy] { + return pulumix.Output[*DeploymentStrategy]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPtrOutput) Elem() DeploymentStrategyOutput { return o.ApplyT(func(v *DeploymentStrategy) DeploymentStrategy { if v != nil { @@ -4871,6 +5496,12 @@ func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchOutput) } +func (i DeploymentStrategyPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeploymentStrategyPatchArgs) ToDeploymentStrategyPatchPtrOutput() DeploymentStrategyPatchPtrOutput { return i.ToDeploymentStrategyPatchPtrOutputWithContext(context.Background()) } @@ -4912,6 +5543,12 @@ func (i *deploymentStrategyPatchPtrType) ToDeploymentStrategyPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(DeploymentStrategyPatchPtrOutput) } +func (i *deploymentStrategyPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: i.ToDeploymentStrategyPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeploymentStrategy describes how to replace existing pods with new ones. type DeploymentStrategyPatchOutput struct{ *pulumi.OutputState } @@ -4937,6 +5574,12 @@ func (o DeploymentStrategyPatchOutput) ToDeploymentStrategyPatchPtrOutputWithCon }).(DeploymentStrategyPatchPtrOutput) } +func (o DeploymentStrategyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeploymentStrategyPatch] { + return pulumix.Output[DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + // Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. func (o DeploymentStrategyPatchOutput) RollingUpdate() RollingUpdateDeploymentPatchPtrOutput { return o.ApplyT(func(v DeploymentStrategyPatch) *RollingUpdateDeploymentPatch { return v.RollingUpdate }).(RollingUpdateDeploymentPatchPtrOutput) @@ -4961,6 +5604,12 @@ func (o DeploymentStrategyPatchPtrOutput) ToDeploymentStrategyPatchPtrOutputWith return o } +func (o DeploymentStrategyPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeploymentStrategyPatch] { + return pulumix.Output[*DeploymentStrategyPatch]{ + OutputState: o.OutputState, + } +} + func (o DeploymentStrategyPatchPtrOutput) Elem() DeploymentStrategyPatchOutput { return o.ApplyT(func(v *DeploymentStrategyPatch) DeploymentStrategyPatch { if v != nil { @@ -5030,6 +5679,12 @@ func (i FSGroupStrategyOptionsArgs) ToFSGroupStrategyOptionsOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsOutput) } +func (i FSGroupStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptions] { + return pulumix.Output[FSGroupStrategyOptions]{ + OutputState: i.ToFSGroupStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i FSGroupStrategyOptionsArgs) ToFSGroupStrategyOptionsPtrOutput() FSGroupStrategyOptionsPtrOutput { return i.ToFSGroupStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -5071,6 +5726,12 @@ func (i *fsgroupStrategyOptionsPtrType) ToFSGroupStrategyOptionsPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsPtrOutput) } +func (i *fsgroupStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptions] { + return pulumix.Output[*FSGroupStrategyOptions]{ + OutputState: i.ToFSGroupStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // FSGroupStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use FSGroupStrategyOptions from policy API Group instead. type FSGroupStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -5096,6 +5757,12 @@ func (o FSGroupStrategyOptionsOutput) ToFSGroupStrategyOptionsPtrOutputWithConte }).(FSGroupStrategyOptionsPtrOutput) } +func (o FSGroupStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptions] { + return pulumix.Output[FSGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. func (o FSGroupStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v FSGroupStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -5120,6 +5787,12 @@ func (o FSGroupStrategyOptionsPtrOutput) ToFSGroupStrategyOptionsPtrOutputWithCo return o } +func (o FSGroupStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptions] { + return pulumix.Output[*FSGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o FSGroupStrategyOptionsPtrOutput) Elem() FSGroupStrategyOptionsOutput { return o.ApplyT(func(v *FSGroupStrategyOptions) FSGroupStrategyOptions { if v != nil { @@ -5189,6 +5862,12 @@ func (i FSGroupStrategyOptionsPatchArgs) ToFSGroupStrategyOptionsPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsPatchOutput) } +func (i FSGroupStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptionsPatch] { + return pulumix.Output[FSGroupStrategyOptionsPatch]{ + OutputState: i.ToFSGroupStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i FSGroupStrategyOptionsPatchArgs) ToFSGroupStrategyOptionsPatchPtrOutput() FSGroupStrategyOptionsPatchPtrOutput { return i.ToFSGroupStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -5230,6 +5909,12 @@ func (i *fsgroupStrategyOptionsPatchPtrType) ToFSGroupStrategyOptionsPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsPatchPtrOutput) } +func (i *fsgroupStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptionsPatch] { + return pulumix.Output[*FSGroupStrategyOptionsPatch]{ + OutputState: i.ToFSGroupStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FSGroupStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use FSGroupStrategyOptions from policy API Group instead. type FSGroupStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -5255,6 +5940,12 @@ func (o FSGroupStrategyOptionsPatchOutput) ToFSGroupStrategyOptionsPatchPtrOutpu }).(FSGroupStrategyOptionsPatchPtrOutput) } +func (o FSGroupStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptionsPatch] { + return pulumix.Output[FSGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. func (o FSGroupStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v FSGroupStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -5279,6 +5970,12 @@ func (o FSGroupStrategyOptionsPatchPtrOutput) ToFSGroupStrategyOptionsPatchPtrOu return o } +func (o FSGroupStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptionsPatch] { + return pulumix.Output[*FSGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o FSGroupStrategyOptionsPatchPtrOutput) Elem() FSGroupStrategyOptionsPatchOutput { return o.ApplyT(func(v *FSGroupStrategyOptionsPatch) FSGroupStrategyOptionsPatch { if v != nil { @@ -5372,6 +6069,12 @@ func (i HTTPIngressPathArgs) ToHTTPIngressPathOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathOutput) } +func (i HTTPIngressPathArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPath] { + return pulumix.Output[HTTPIngressPath]{ + OutputState: i.ToHTTPIngressPathOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPathArrayInput is an input type that accepts HTTPIngressPathArray and HTTPIngressPathArrayOutput values. // You can construct a concrete instance of `HTTPIngressPathArrayInput` via: // @@ -5397,6 +6100,12 @@ func (i HTTPIngressPathArray) ToHTTPIngressPathArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathArrayOutput) } +func (i HTTPIngressPathArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPath] { + return pulumix.Output[[]HTTPIngressPath]{ + OutputState: i.ToHTTPIngressPathArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. type HTTPIngressPathOutput struct{ *pulumi.OutputState } @@ -5412,6 +6121,12 @@ func (o HTTPIngressPathOutput) ToHTTPIngressPathOutputWithContext(ctx context.Co return o } +func (o HTTPIngressPathOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPath] { + return pulumix.Output[HTTPIngressPath]{ + OutputState: o.OutputState, + } +} + // Backend defines the referenced service endpoint to which the traffic will be forwarded to. func (o HTTPIngressPathOutput) Backend() IngressBackendOutput { return o.ApplyT(func(v HTTPIngressPath) IngressBackend { return v.Backend }).(IngressBackendOutput) @@ -5452,6 +6167,12 @@ func (o HTTPIngressPathArrayOutput) ToHTTPIngressPathArrayOutputWithContext(ctx return o } +func (o HTTPIngressPathArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPath] { + return pulumix.Output[[]HTTPIngressPath]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressPathArrayOutput) Index(i pulumi.IntInput) HTTPIngressPathOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPIngressPath { return vs[0].([]HTTPIngressPath)[vs[1].(int)] @@ -5521,6 +6242,12 @@ func (i HTTPIngressPathPatchArgs) ToHTTPIngressPathPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathPatchOutput) } +func (i HTTPIngressPathPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPathPatch] { + return pulumix.Output[HTTPIngressPathPatch]{ + OutputState: i.ToHTTPIngressPathPatchOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPathPatchArrayInput is an input type that accepts HTTPIngressPathPatchArray and HTTPIngressPathPatchArrayOutput values. // You can construct a concrete instance of `HTTPIngressPathPatchArrayInput` via: // @@ -5546,6 +6273,12 @@ func (i HTTPIngressPathPatchArray) ToHTTPIngressPathPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathPatchArrayOutput) } +func (i HTTPIngressPathPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPathPatch] { + return pulumix.Output[[]HTTPIngressPathPatch]{ + OutputState: i.ToHTTPIngressPathPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. type HTTPIngressPathPatchOutput struct{ *pulumi.OutputState } @@ -5561,6 +6294,12 @@ func (o HTTPIngressPathPatchOutput) ToHTTPIngressPathPatchOutputWithContext(ctx return o } +func (o HTTPIngressPathPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPathPatch] { + return pulumix.Output[HTTPIngressPathPatch]{ + OutputState: o.OutputState, + } +} + // Backend defines the referenced service endpoint to which the traffic will be forwarded to. func (o HTTPIngressPathPatchOutput) Backend() IngressBackendPatchPtrOutput { return o.ApplyT(func(v HTTPIngressPathPatch) *IngressBackendPatch { return v.Backend }).(IngressBackendPatchPtrOutput) @@ -5601,6 +6340,12 @@ func (o HTTPIngressPathPatchArrayOutput) ToHTTPIngressPathPatchArrayOutputWithCo return o } +func (o HTTPIngressPathPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPathPatch] { + return pulumix.Output[[]HTTPIngressPathPatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressPathPatchArrayOutput) Index(i pulumi.IntInput) HTTPIngressPathPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPIngressPathPatch { return vs[0].([]HTTPIngressPathPatch)[vs[1].(int)] @@ -5642,6 +6387,12 @@ func (i HTTPIngressRuleValueArgs) ToHTTPIngressRuleValueOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValueOutput) } +func (i HTTPIngressRuleValueArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValue] { + return pulumix.Output[HTTPIngressRuleValue]{ + OutputState: i.ToHTTPIngressRuleValueOutputWithContext(ctx).OutputState, + } +} + func (i HTTPIngressRuleValueArgs) ToHTTPIngressRuleValuePtrOutput() HTTPIngressRuleValuePtrOutput { return i.ToHTTPIngressRuleValuePtrOutputWithContext(context.Background()) } @@ -5683,6 +6434,12 @@ func (i *httpingressRuleValuePtrType) ToHTTPIngressRuleValuePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePtrOutput) } +func (i *httpingressRuleValuePtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValue] { + return pulumix.Output[*HTTPIngressRuleValue]{ + OutputState: i.ToHTTPIngressRuleValuePtrOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. type HTTPIngressRuleValueOutput struct{ *pulumi.OutputState } @@ -5708,6 +6465,12 @@ func (o HTTPIngressRuleValueOutput) ToHTTPIngressRuleValuePtrOutputWithContext(c }).(HTTPIngressRuleValuePtrOutput) } +func (o HTTPIngressRuleValueOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValue] { + return pulumix.Output[HTTPIngressRuleValue]{ + OutputState: o.OutputState, + } +} + // A collection of paths that map requests to backends. func (o HTTPIngressRuleValueOutput) Paths() HTTPIngressPathArrayOutput { return o.ApplyT(func(v HTTPIngressRuleValue) []HTTPIngressPath { return v.Paths }).(HTTPIngressPathArrayOutput) @@ -5727,6 +6490,12 @@ func (o HTTPIngressRuleValuePtrOutput) ToHTTPIngressRuleValuePtrOutputWithContex return o } +func (o HTTPIngressRuleValuePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValue] { + return pulumix.Output[*HTTPIngressRuleValue]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressRuleValuePtrOutput) Elem() HTTPIngressRuleValueOutput { return o.ApplyT(func(v *HTTPIngressRuleValue) HTTPIngressRuleValue { if v != nil { @@ -5782,6 +6551,12 @@ func (i HTTPIngressRuleValuePatchArgs) ToHTTPIngressRuleValuePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePatchOutput) } +func (i HTTPIngressRuleValuePatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValuePatch] { + return pulumix.Output[HTTPIngressRuleValuePatch]{ + OutputState: i.ToHTTPIngressRuleValuePatchOutputWithContext(ctx).OutputState, + } +} + func (i HTTPIngressRuleValuePatchArgs) ToHTTPIngressRuleValuePatchPtrOutput() HTTPIngressRuleValuePatchPtrOutput { return i.ToHTTPIngressRuleValuePatchPtrOutputWithContext(context.Background()) } @@ -5823,6 +6598,12 @@ func (i *httpingressRuleValuePatchPtrType) ToHTTPIngressRuleValuePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePatchPtrOutput) } +func (i *httpingressRuleValuePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValuePatch] { + return pulumix.Output[*HTTPIngressRuleValuePatch]{ + OutputState: i.ToHTTPIngressRuleValuePatchPtrOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. type HTTPIngressRuleValuePatchOutput struct{ *pulumi.OutputState } @@ -5848,6 +6629,12 @@ func (o HTTPIngressRuleValuePatchOutput) ToHTTPIngressRuleValuePatchPtrOutputWit }).(HTTPIngressRuleValuePatchPtrOutput) } +func (o HTTPIngressRuleValuePatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValuePatch] { + return pulumix.Output[HTTPIngressRuleValuePatch]{ + OutputState: o.OutputState, + } +} + // A collection of paths that map requests to backends. func (o HTTPIngressRuleValuePatchOutput) Paths() HTTPIngressPathPatchArrayOutput { return o.ApplyT(func(v HTTPIngressRuleValuePatch) []HTTPIngressPathPatch { return v.Paths }).(HTTPIngressPathPatchArrayOutput) @@ -5867,6 +6654,12 @@ func (o HTTPIngressRuleValuePatchPtrOutput) ToHTTPIngressRuleValuePatchPtrOutput return o } +func (o HTTPIngressRuleValuePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValuePatch] { + return pulumix.Output[*HTTPIngressRuleValuePatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressRuleValuePatchPtrOutput) Elem() HTTPIngressRuleValuePatchOutput { return o.ApplyT(func(v *HTTPIngressRuleValuePatch) HTTPIngressRuleValuePatch { if v != nil { @@ -5926,6 +6719,12 @@ func (i HostPortRangeArgs) ToHostPortRangeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(HostPortRangeOutput) } +func (i HostPortRangeArgs) ToOutput(ctx context.Context) pulumix.Output[HostPortRange] { + return pulumix.Output[HostPortRange]{ + OutputState: i.ToHostPortRangeOutputWithContext(ctx).OutputState, + } +} + // HostPortRangeArrayInput is an input type that accepts HostPortRangeArray and HostPortRangeArrayOutput values. // You can construct a concrete instance of `HostPortRangeArrayInput` via: // @@ -5951,6 +6750,12 @@ func (i HostPortRangeArray) ToHostPortRangeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(HostPortRangeArrayOutput) } +func (i HostPortRangeArray) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRange] { + return pulumix.Output[[]HostPortRange]{ + OutputState: i.ToHostPortRangeArrayOutputWithContext(ctx).OutputState, + } +} + // HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. Deprecated: use HostPortRange from policy API Group instead. type HostPortRangeOutput struct{ *pulumi.OutputState } @@ -5966,6 +6771,12 @@ func (o HostPortRangeOutput) ToHostPortRangeOutputWithContext(ctx context.Contex return o } +func (o HostPortRangeOutput) ToOutput(ctx context.Context) pulumix.Output[HostPortRange] { + return pulumix.Output[HostPortRange]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o HostPortRangeOutput) Max() pulumi.IntOutput { return o.ApplyT(func(v HostPortRange) int { return v.Max }).(pulumi.IntOutput) @@ -5990,6 +6801,12 @@ func (o HostPortRangeArrayOutput) ToHostPortRangeArrayOutputWithContext(ctx cont return o } +func (o HostPortRangeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRange] { + return pulumix.Output[[]HostPortRange]{ + OutputState: o.OutputState, + } +} + func (o HostPortRangeArrayOutput) Index(i pulumi.IntInput) HostPortRangeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostPortRange { return vs[0].([]HostPortRange)[vs[1].(int)] @@ -6035,6 +6852,12 @@ func (i HostPortRangePatchArgs) ToHostPortRangePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HostPortRangePatchOutput) } +func (i HostPortRangePatchArgs) ToOutput(ctx context.Context) pulumix.Output[HostPortRangePatch] { + return pulumix.Output[HostPortRangePatch]{ + OutputState: i.ToHostPortRangePatchOutputWithContext(ctx).OutputState, + } +} + // HostPortRangePatchArrayInput is an input type that accepts HostPortRangePatchArray and HostPortRangePatchArrayOutput values. // You can construct a concrete instance of `HostPortRangePatchArrayInput` via: // @@ -6060,6 +6883,12 @@ func (i HostPortRangePatchArray) ToHostPortRangePatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HostPortRangePatchArrayOutput) } +func (i HostPortRangePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRangePatch] { + return pulumix.Output[[]HostPortRangePatch]{ + OutputState: i.ToHostPortRangePatchArrayOutputWithContext(ctx).OutputState, + } +} + // HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. Deprecated: use HostPortRange from policy API Group instead. type HostPortRangePatchOutput struct{ *pulumi.OutputState } @@ -6075,6 +6904,12 @@ func (o HostPortRangePatchOutput) ToHostPortRangePatchOutputWithContext(ctx cont return o } +func (o HostPortRangePatchOutput) ToOutput(ctx context.Context) pulumix.Output[HostPortRangePatch] { + return pulumix.Output[HostPortRangePatch]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o HostPortRangePatchOutput) Max() pulumi.IntPtrOutput { return o.ApplyT(func(v HostPortRangePatch) *int { return v.Max }).(pulumi.IntPtrOutput) @@ -6099,6 +6934,12 @@ func (o HostPortRangePatchArrayOutput) ToHostPortRangePatchArrayOutputWithContex return o } +func (o HostPortRangePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRangePatch] { + return pulumix.Output[[]HostPortRangePatch]{ + OutputState: o.OutputState, + } +} + func (o HostPortRangePatchArrayOutput) Index(i pulumi.IntInput) HostPortRangePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostPortRangePatch { return vs[0].([]HostPortRangePatch)[vs[1].(int)] @@ -6144,6 +6985,12 @@ func (i IDRangeArgs) ToIDRangeOutputWithContext(ctx context.Context) IDRangeOutp return pulumi.ToOutputWithContext(ctx, i).(IDRangeOutput) } +func (i IDRangeArgs) ToOutput(ctx context.Context) pulumix.Output[IDRange] { + return pulumix.Output[IDRange]{ + OutputState: i.ToIDRangeOutputWithContext(ctx).OutputState, + } +} + // IDRangeArrayInput is an input type that accepts IDRangeArray and IDRangeArrayOutput values. // You can construct a concrete instance of `IDRangeArrayInput` via: // @@ -6169,6 +7016,12 @@ func (i IDRangeArray) ToIDRangeArrayOutputWithContext(ctx context.Context) IDRan return pulumi.ToOutputWithContext(ctx, i).(IDRangeArrayOutput) } +func (i IDRangeArray) ToOutput(ctx context.Context) pulumix.Output[[]IDRange] { + return pulumix.Output[[]IDRange]{ + OutputState: i.ToIDRangeArrayOutputWithContext(ctx).OutputState, + } +} + // IDRange provides a min/max of an allowed range of IDs. Deprecated: use IDRange from policy API Group instead. type IDRangeOutput struct{ *pulumi.OutputState } @@ -6184,6 +7037,12 @@ func (o IDRangeOutput) ToIDRangeOutputWithContext(ctx context.Context) IDRangeOu return o } +func (o IDRangeOutput) ToOutput(ctx context.Context) pulumix.Output[IDRange] { + return pulumix.Output[IDRange]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o IDRangeOutput) Max() pulumi.IntOutput { return o.ApplyT(func(v IDRange) int { return v.Max }).(pulumi.IntOutput) @@ -6208,6 +7067,12 @@ func (o IDRangeArrayOutput) ToIDRangeArrayOutputWithContext(ctx context.Context) return o } +func (o IDRangeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IDRange] { + return pulumix.Output[[]IDRange]{ + OutputState: o.OutputState, + } +} + func (o IDRangeArrayOutput) Index(i pulumi.IntInput) IDRangeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IDRange { return vs[0].([]IDRange)[vs[1].(int)] @@ -6253,6 +7118,12 @@ func (i IDRangePatchArgs) ToIDRangePatchOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IDRangePatchOutput) } +func (i IDRangePatchArgs) ToOutput(ctx context.Context) pulumix.Output[IDRangePatch] { + return pulumix.Output[IDRangePatch]{ + OutputState: i.ToIDRangePatchOutputWithContext(ctx).OutputState, + } +} + // IDRangePatchArrayInput is an input type that accepts IDRangePatchArray and IDRangePatchArrayOutput values. // You can construct a concrete instance of `IDRangePatchArrayInput` via: // @@ -6278,6 +7149,12 @@ func (i IDRangePatchArray) ToIDRangePatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IDRangePatchArrayOutput) } +func (i IDRangePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IDRangePatch] { + return pulumix.Output[[]IDRangePatch]{ + OutputState: i.ToIDRangePatchArrayOutputWithContext(ctx).OutputState, + } +} + // IDRange provides a min/max of an allowed range of IDs. Deprecated: use IDRange from policy API Group instead. type IDRangePatchOutput struct{ *pulumi.OutputState } @@ -6293,6 +7170,12 @@ func (o IDRangePatchOutput) ToIDRangePatchOutputWithContext(ctx context.Context) return o } +func (o IDRangePatchOutput) ToOutput(ctx context.Context) pulumix.Output[IDRangePatch] { + return pulumix.Output[IDRangePatch]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o IDRangePatchOutput) Max() pulumi.IntPtrOutput { return o.ApplyT(func(v IDRangePatch) *int { return v.Max }).(pulumi.IntPtrOutput) @@ -6317,6 +7200,12 @@ func (o IDRangePatchArrayOutput) ToIDRangePatchArrayOutputWithContext(ctx contex return o } +func (o IDRangePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IDRangePatch] { + return pulumix.Output[[]IDRangePatch]{ + OutputState: o.OutputState, + } +} + func (o IDRangePatchArrayOutput) Index(i pulumi.IntInput) IDRangePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IDRangePatch { return vs[0].([]IDRangePatch)[vs[1].(int)] @@ -6362,6 +7251,12 @@ func (i IPBlockArgs) ToIPBlockOutputWithContext(ctx context.Context) IPBlockOutp return pulumi.ToOutputWithContext(ctx, i).(IPBlockOutput) } +func (i IPBlockArgs) ToOutput(ctx context.Context) pulumix.Output[IPBlock] { + return pulumix.Output[IPBlock]{ + OutputState: i.ToIPBlockOutputWithContext(ctx).OutputState, + } +} + func (i IPBlockArgs) ToIPBlockPtrOutput() IPBlockPtrOutput { return i.ToIPBlockPtrOutputWithContext(context.Background()) } @@ -6403,6 +7298,12 @@ func (i *ipblockPtrType) ToIPBlockPtrOutputWithContext(ctx context.Context) IPBl return pulumi.ToOutputWithContext(ctx, i).(IPBlockPtrOutput) } +func (i *ipblockPtrType) ToOutput(ctx context.Context) pulumix.Output[*IPBlock] { + return pulumix.Output[*IPBlock]{ + OutputState: i.ToIPBlockPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of IPBlock is deprecated by networking/v1/IPBlock. IPBlock describes a particular CIDR (Ex. "192.168.1.1/24") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule. type IPBlockOutput struct{ *pulumi.OutputState } @@ -6428,6 +7329,12 @@ func (o IPBlockOutput) ToIPBlockPtrOutputWithContext(ctx context.Context) IPBloc }).(IPBlockPtrOutput) } +func (o IPBlockOutput) ToOutput(ctx context.Context) pulumix.Output[IPBlock] { + return pulumix.Output[IPBlock]{ + OutputState: o.OutputState, + } +} + // CIDR is a string representing the IP Block Valid examples are "192.168.1.1/24" func (o IPBlockOutput) Cidr() pulumi.StringOutput { return o.ApplyT(func(v IPBlock) string { return v.Cidr }).(pulumi.StringOutput) @@ -6452,6 +7359,12 @@ func (o IPBlockPtrOutput) ToIPBlockPtrOutputWithContext(ctx context.Context) IPB return o } +func (o IPBlockPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IPBlock] { + return pulumix.Output[*IPBlock]{ + OutputState: o.OutputState, + } +} + func (o IPBlockPtrOutput) Elem() IPBlockOutput { return o.ApplyT(func(v *IPBlock) IPBlock { if v != nil { @@ -6521,6 +7434,12 @@ func (i IPBlockPatchArgs) ToIPBlockPatchOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IPBlockPatchOutput) } +func (i IPBlockPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IPBlockPatch] { + return pulumix.Output[IPBlockPatch]{ + OutputState: i.ToIPBlockPatchOutputWithContext(ctx).OutputState, + } +} + func (i IPBlockPatchArgs) ToIPBlockPatchPtrOutput() IPBlockPatchPtrOutput { return i.ToIPBlockPatchPtrOutputWithContext(context.Background()) } @@ -6562,6 +7481,12 @@ func (i *ipblockPatchPtrType) ToIPBlockPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(IPBlockPatchPtrOutput) } +func (i *ipblockPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IPBlockPatch] { + return pulumix.Output[*IPBlockPatch]{ + OutputState: i.ToIPBlockPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of IPBlock is deprecated by networking/v1/IPBlock. IPBlock describes a particular CIDR (Ex. "192.168.1.1/24") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule. type IPBlockPatchOutput struct{ *pulumi.OutputState } @@ -6587,6 +7512,12 @@ func (o IPBlockPatchOutput) ToIPBlockPatchPtrOutputWithContext(ctx context.Conte }).(IPBlockPatchPtrOutput) } +func (o IPBlockPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IPBlockPatch] { + return pulumix.Output[IPBlockPatch]{ + OutputState: o.OutputState, + } +} + // CIDR is a string representing the IP Block Valid examples are "192.168.1.1/24" func (o IPBlockPatchOutput) Cidr() pulumi.StringPtrOutput { return o.ApplyT(func(v IPBlockPatch) *string { return v.Cidr }).(pulumi.StringPtrOutput) @@ -6611,6 +7542,12 @@ func (o IPBlockPatchPtrOutput) ToIPBlockPatchPtrOutputWithContext(ctx context.Co return o } +func (o IPBlockPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IPBlockPatch] { + return pulumix.Output[*IPBlockPatch]{ + OutputState: o.OutputState, + } +} + func (o IPBlockPatchPtrOutput) Elem() IPBlockPatchOutput { return o.ApplyT(func(v *IPBlockPatch) IPBlockPatch { if v != nil { @@ -6720,6 +7657,12 @@ func (i IngressTypeArgs) ToIngressTypeOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressTypeOutput) } +func (i IngressTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressType] { + return pulumix.Output[IngressType]{ + OutputState: i.ToIngressTypeOutputWithContext(ctx).OutputState, + } +} + // IngressTypeArrayInput is an input type that accepts IngressTypeArray and IngressTypeArrayOutput values. // You can construct a concrete instance of `IngressTypeArrayInput` via: // @@ -6745,6 +7688,12 @@ func (i IngressTypeArray) ToIngressTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressTypeArrayOutput) } +func (i IngressTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressType] { + return pulumix.Output[[]IngressType]{ + OutputState: i.ToIngressTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. // // This resource waits until its status is ready before registering success @@ -6774,6 +7723,12 @@ func (o IngressTypeOutput) ToIngressTypeOutputWithContext(ctx context.Context) I return o } +func (o IngressTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressType] { + return pulumix.Output[IngressType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6813,6 +7768,12 @@ func (o IngressTypeArrayOutput) ToIngressTypeArrayOutputWithContext(ctx context. return o } +func (o IngressTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressType] { + return pulumix.Output[[]IngressType]{ + OutputState: o.OutputState, + } +} + func (o IngressTypeArrayOutput) Index(i pulumi.IntInput) IngressTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressType { return vs[0].([]IngressType)[vs[1].(int)] @@ -6862,6 +7823,12 @@ func (i IngressBackendArgs) ToIngressBackendOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressBackendOutput) } +func (i IngressBackendArgs) ToOutput(ctx context.Context) pulumix.Output[IngressBackend] { + return pulumix.Output[IngressBackend]{ + OutputState: i.ToIngressBackendOutputWithContext(ctx).OutputState, + } +} + func (i IngressBackendArgs) ToIngressBackendPtrOutput() IngressBackendPtrOutput { return i.ToIngressBackendPtrOutputWithContext(context.Background()) } @@ -6903,6 +7870,12 @@ func (i *ingressBackendPtrType) ToIngressBackendPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPtrOutput) } +func (i *ingressBackendPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressBackend] { + return pulumix.Output[*IngressBackend]{ + OutputState: i.ToIngressBackendPtrOutputWithContext(ctx).OutputState, + } +} + // IngressBackend describes all endpoints for a given service and port. type IngressBackendOutput struct{ *pulumi.OutputState } @@ -6928,6 +7901,12 @@ func (o IngressBackendOutput) ToIngressBackendPtrOutputWithContext(ctx context.C }).(IngressBackendPtrOutput) } +func (o IngressBackendOutput) ToOutput(ctx context.Context) pulumix.Output[IngressBackend] { + return pulumix.Output[IngressBackend]{ + OutputState: o.OutputState, + } +} + // Resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, serviceName and servicePort must not be specified. func (o IngressBackendOutput) Resource() corev1.TypedLocalObjectReferencePtrOutput { return o.ApplyT(func(v IngressBackend) *corev1.TypedLocalObjectReference { return v.Resource }).(corev1.TypedLocalObjectReferencePtrOutput) @@ -6957,6 +7936,12 @@ func (o IngressBackendPtrOutput) ToIngressBackendPtrOutputWithContext(ctx contex return o } +func (o IngressBackendPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressBackend] { + return pulumix.Output[*IngressBackend]{ + OutputState: o.OutputState, + } +} + func (o IngressBackendPtrOutput) Elem() IngressBackendOutput { return o.ApplyT(func(v *IngressBackend) IngressBackend { if v != nil { @@ -7040,6 +8025,12 @@ func (i IngressBackendPatchArgs) ToIngressBackendPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPatchOutput) } +func (i IngressBackendPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressBackendPatch] { + return pulumix.Output[IngressBackendPatch]{ + OutputState: i.ToIngressBackendPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressBackendPatchArgs) ToIngressBackendPatchPtrOutput() IngressBackendPatchPtrOutput { return i.ToIngressBackendPatchPtrOutputWithContext(context.Background()) } @@ -7081,6 +8072,12 @@ func (i *ingressBackendPatchPtrType) ToIngressBackendPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPatchPtrOutput) } +func (i *ingressBackendPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressBackendPatch] { + return pulumix.Output[*IngressBackendPatch]{ + OutputState: i.ToIngressBackendPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressBackend describes all endpoints for a given service and port. type IngressBackendPatchOutput struct{ *pulumi.OutputState } @@ -7106,6 +8103,12 @@ func (o IngressBackendPatchOutput) ToIngressBackendPatchPtrOutputWithContext(ctx }).(IngressBackendPatchPtrOutput) } +func (o IngressBackendPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressBackendPatch] { + return pulumix.Output[IngressBackendPatch]{ + OutputState: o.OutputState, + } +} + // Resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, serviceName and servicePort must not be specified. func (o IngressBackendPatchOutput) Resource() corev1.TypedLocalObjectReferencePatchPtrOutput { return o.ApplyT(func(v IngressBackendPatch) *corev1.TypedLocalObjectReferencePatch { return v.Resource }).(corev1.TypedLocalObjectReferencePatchPtrOutput) @@ -7135,6 +8138,12 @@ func (o IngressBackendPatchPtrOutput) ToIngressBackendPatchPtrOutputWithContext( return o } +func (o IngressBackendPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressBackendPatch] { + return pulumix.Output[*IngressBackendPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressBackendPatchPtrOutput) Elem() IngressBackendPatchOutput { return o.ApplyT(func(v *IngressBackendPatch) IngressBackendPatch { if v != nil { @@ -7222,6 +8231,12 @@ func (i IngressListTypeArgs) ToIngressListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressListTypeOutput) } +func (i IngressListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressListType] { + return pulumix.Output[IngressListType]{ + OutputState: i.ToIngressListTypeOutputWithContext(ctx).OutputState, + } +} + // IngressList is a collection of Ingress. type IngressListTypeOutput struct{ *pulumi.OutputState } @@ -7237,6 +8252,12 @@ func (o IngressListTypeOutput) ToIngressListTypeOutputWithContext(ctx context.Co return o } +func (o IngressListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressListType] { + return pulumix.Output[IngressListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7336,6 +8357,12 @@ func (i IngressPatchTypeArgs) ToIngressPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressPatchTypeOutput) } +func (i IngressPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressPatchType] { + return pulumix.Output[IngressPatchType]{ + OutputState: i.ToIngressPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. // // This resource waits until its status is ready before registering success @@ -7365,6 +8392,12 @@ func (o IngressPatchTypeOutput) ToIngressPatchTypeOutputWithContext(ctx context. return o } +func (o IngressPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressPatchType] { + return pulumix.Output[IngressPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -7437,6 +8470,12 @@ func (i IngressRuleArgs) ToIngressRuleOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressRuleOutput) } +func (i IngressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[IngressRule] { + return pulumix.Output[IngressRule]{ + OutputState: i.ToIngressRuleOutputWithContext(ctx).OutputState, + } +} + // IngressRuleArrayInput is an input type that accepts IngressRuleArray and IngressRuleArrayOutput values. // You can construct a concrete instance of `IngressRuleArrayInput` via: // @@ -7462,6 +8501,12 @@ func (i IngressRuleArray) ToIngressRuleArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressRuleArrayOutput) } +func (i IngressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressRule] { + return pulumix.Output[[]IngressRule]{ + OutputState: i.ToIngressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. type IngressRuleOutput struct{ *pulumi.OutputState } @@ -7477,6 +8522,12 @@ func (o IngressRuleOutput) ToIngressRuleOutputWithContext(ctx context.Context) I return o } +func (o IngressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[IngressRule] { + return pulumix.Output[IngressRule]{ + OutputState: o.OutputState, + } +} + // Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the // // IP in the Spec of the parent Ingress. @@ -7507,6 +8558,12 @@ func (o IngressRuleArrayOutput) ToIngressRuleArrayOutputWithContext(ctx context. return o } +func (o IngressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressRule] { + return pulumix.Output[[]IngressRule]{ + OutputState: o.OutputState, + } +} + func (o IngressRuleArrayOutput) Index(i pulumi.IntInput) IngressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressRule { return vs[0].([]IngressRule)[vs[1].(int)] @@ -7560,6 +8617,12 @@ func (i IngressRulePatchArgs) ToIngressRulePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressRulePatchOutput) } +func (i IngressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressRulePatch] { + return pulumix.Output[IngressRulePatch]{ + OutputState: i.ToIngressRulePatchOutputWithContext(ctx).OutputState, + } +} + // IngressRulePatchArrayInput is an input type that accepts IngressRulePatchArray and IngressRulePatchArrayOutput values. // You can construct a concrete instance of `IngressRulePatchArrayInput` via: // @@ -7585,6 +8648,12 @@ func (i IngressRulePatchArray) ToIngressRulePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressRulePatchArrayOutput) } +func (i IngressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressRulePatch] { + return pulumix.Output[[]IngressRulePatch]{ + OutputState: i.ToIngressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. type IngressRulePatchOutput struct{ *pulumi.OutputState } @@ -7600,6 +8669,12 @@ func (o IngressRulePatchOutput) ToIngressRulePatchOutputWithContext(ctx context. return o } +func (o IngressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressRulePatch] { + return pulumix.Output[IngressRulePatch]{ + OutputState: o.OutputState, + } +} + // Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the // // IP in the Spec of the parent Ingress. @@ -7630,6 +8705,12 @@ func (o IngressRulePatchArrayOutput) ToIngressRulePatchArrayOutputWithContext(ct return o } +func (o IngressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressRulePatch] { + return pulumix.Output[[]IngressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o IngressRulePatchArrayOutput) Index(i pulumi.IntInput) IngressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressRulePatch { return vs[0].([]IngressRulePatch)[vs[1].(int)] @@ -7683,6 +8764,12 @@ func (i IngressSpecArgs) ToIngressSpecOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressSpecOutput) } +func (i IngressSpecArgs) ToOutput(ctx context.Context) pulumix.Output[IngressSpec] { + return pulumix.Output[IngressSpec]{ + OutputState: i.ToIngressSpecOutputWithContext(ctx).OutputState, + } +} + func (i IngressSpecArgs) ToIngressSpecPtrOutput() IngressSpecPtrOutput { return i.ToIngressSpecPtrOutputWithContext(context.Background()) } @@ -7724,6 +8811,12 @@ func (i *ingressSpecPtrType) ToIngressSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPtrOutput) } +func (i *ingressSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressSpec] { + return pulumix.Output[*IngressSpec]{ + OutputState: i.ToIngressSpecPtrOutputWithContext(ctx).OutputState, + } +} + // IngressSpec describes the Ingress the user wishes to exist. type IngressSpecOutput struct{ *pulumi.OutputState } @@ -7749,6 +8842,12 @@ func (o IngressSpecOutput) ToIngressSpecPtrOutputWithContext(ctx context.Context }).(IngressSpecPtrOutput) } +func (o IngressSpecOutput) ToOutput(ctx context.Context) pulumix.Output[IngressSpec] { + return pulumix.Output[IngressSpec]{ + OutputState: o.OutputState, + } +} + // A default backend capable of servicing requests that don't match any rule. At least one of 'backend' or 'rules' must be specified. This field is optional to allow the loadbalancer controller or defaulting logic to specify a global default. func (o IngressSpecOutput) Backend() IngressBackendPtrOutput { return o.ApplyT(func(v IngressSpec) *IngressBackend { return v.Backend }).(IngressBackendPtrOutput) @@ -7783,6 +8882,12 @@ func (o IngressSpecPtrOutput) ToIngressSpecPtrOutputWithContext(ctx context.Cont return o } +func (o IngressSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressSpec] { + return pulumix.Output[*IngressSpec]{ + OutputState: o.OutputState, + } +} + func (o IngressSpecPtrOutput) Elem() IngressSpecOutput { return o.ApplyT(func(v *IngressSpec) IngressSpec { if v != nil { @@ -7880,6 +8985,12 @@ func (i IngressSpecPatchArgs) ToIngressSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPatchOutput) } +func (i IngressSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressSpecPatch] { + return pulumix.Output[IngressSpecPatch]{ + OutputState: i.ToIngressSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressSpecPatchArgs) ToIngressSpecPatchPtrOutput() IngressSpecPatchPtrOutput { return i.ToIngressSpecPatchPtrOutputWithContext(context.Background()) } @@ -7921,6 +9032,12 @@ func (i *ingressSpecPatchPtrType) ToIngressSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPatchPtrOutput) } +func (i *ingressSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressSpecPatch] { + return pulumix.Output[*IngressSpecPatch]{ + OutputState: i.ToIngressSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressSpec describes the Ingress the user wishes to exist. type IngressSpecPatchOutput struct{ *pulumi.OutputState } @@ -7946,6 +9063,12 @@ func (o IngressSpecPatchOutput) ToIngressSpecPatchPtrOutputWithContext(ctx conte }).(IngressSpecPatchPtrOutput) } +func (o IngressSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressSpecPatch] { + return pulumix.Output[IngressSpecPatch]{ + OutputState: o.OutputState, + } +} + // A default backend capable of servicing requests that don't match any rule. At least one of 'backend' or 'rules' must be specified. This field is optional to allow the loadbalancer controller or defaulting logic to specify a global default. func (o IngressSpecPatchOutput) Backend() IngressBackendPatchPtrOutput { return o.ApplyT(func(v IngressSpecPatch) *IngressBackendPatch { return v.Backend }).(IngressBackendPatchPtrOutput) @@ -7980,6 +9103,12 @@ func (o IngressSpecPatchPtrOutput) ToIngressSpecPatchPtrOutputWithContext(ctx co return o } +func (o IngressSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressSpecPatch] { + return pulumix.Output[*IngressSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressSpecPatchPtrOutput) Elem() IngressSpecPatchOutput { return o.ApplyT(func(v *IngressSpecPatch) IngressSpecPatch { if v != nil { @@ -8065,6 +9194,12 @@ func (i IngressStatusArgs) ToIngressStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressStatusOutput) } +func (i IngressStatusArgs) ToOutput(ctx context.Context) pulumix.Output[IngressStatus] { + return pulumix.Output[IngressStatus]{ + OutputState: i.ToIngressStatusOutputWithContext(ctx).OutputState, + } +} + func (i IngressStatusArgs) ToIngressStatusPtrOutput() IngressStatusPtrOutput { return i.ToIngressStatusPtrOutputWithContext(context.Background()) } @@ -8106,6 +9241,12 @@ func (i *ingressStatusPtrType) ToIngressStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPtrOutput) } +func (i *ingressStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressStatus] { + return pulumix.Output[*IngressStatus]{ + OutputState: i.ToIngressStatusPtrOutputWithContext(ctx).OutputState, + } +} + // IngressStatus describe the current state of the Ingress. type IngressStatusOutput struct{ *pulumi.OutputState } @@ -8131,6 +9272,12 @@ func (o IngressStatusOutput) ToIngressStatusPtrOutputWithContext(ctx context.Con }).(IngressStatusPtrOutput) } +func (o IngressStatusOutput) ToOutput(ctx context.Context) pulumix.Output[IngressStatus] { + return pulumix.Output[IngressStatus]{ + OutputState: o.OutputState, + } +} + // LoadBalancer contains the current status of the load-balancer. func (o IngressStatusOutput) LoadBalancer() corev1.LoadBalancerStatusPtrOutput { return o.ApplyT(func(v IngressStatus) *corev1.LoadBalancerStatus { return v.LoadBalancer }).(corev1.LoadBalancerStatusPtrOutput) @@ -8150,6 +9297,12 @@ func (o IngressStatusPtrOutput) ToIngressStatusPtrOutputWithContext(ctx context. return o } +func (o IngressStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressStatus] { + return pulumix.Output[*IngressStatus]{ + OutputState: o.OutputState, + } +} + func (o IngressStatusPtrOutput) Elem() IngressStatusOutput { return o.ApplyT(func(v *IngressStatus) IngressStatus { if v != nil { @@ -8205,6 +9358,12 @@ func (i IngressStatusPatchArgs) ToIngressStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPatchOutput) } +func (i IngressStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressStatusPatch] { + return pulumix.Output[IngressStatusPatch]{ + OutputState: i.ToIngressStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressStatusPatchArgs) ToIngressStatusPatchPtrOutput() IngressStatusPatchPtrOutput { return i.ToIngressStatusPatchPtrOutputWithContext(context.Background()) } @@ -8246,6 +9405,12 @@ func (i *ingressStatusPatchPtrType) ToIngressStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPatchPtrOutput) } +func (i *ingressStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressStatusPatch] { + return pulumix.Output[*IngressStatusPatch]{ + OutputState: i.ToIngressStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressStatus describe the current state of the Ingress. type IngressStatusPatchOutput struct{ *pulumi.OutputState } @@ -8271,6 +9436,12 @@ func (o IngressStatusPatchOutput) ToIngressStatusPatchPtrOutputWithContext(ctx c }).(IngressStatusPatchPtrOutput) } +func (o IngressStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressStatusPatch] { + return pulumix.Output[IngressStatusPatch]{ + OutputState: o.OutputState, + } +} + // LoadBalancer contains the current status of the load-balancer. func (o IngressStatusPatchOutput) LoadBalancer() corev1.LoadBalancerStatusPatchPtrOutput { return o.ApplyT(func(v IngressStatusPatch) *corev1.LoadBalancerStatusPatch { return v.LoadBalancer }).(corev1.LoadBalancerStatusPatchPtrOutput) @@ -8290,6 +9461,12 @@ func (o IngressStatusPatchPtrOutput) ToIngressStatusPatchPtrOutputWithContext(ct return o } +func (o IngressStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressStatusPatch] { + return pulumix.Output[*IngressStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressStatusPatchPtrOutput) Elem() IngressStatusPatchOutput { return o.ApplyT(func(v *IngressStatusPatch) IngressStatusPatch { if v != nil { @@ -8349,6 +9526,12 @@ func (i IngressTLSArgs) ToIngressTLSOutputWithContext(ctx context.Context) Ingre return pulumi.ToOutputWithContext(ctx, i).(IngressTLSOutput) } +func (i IngressTLSArgs) ToOutput(ctx context.Context) pulumix.Output[IngressTLS] { + return pulumix.Output[IngressTLS]{ + OutputState: i.ToIngressTLSOutputWithContext(ctx).OutputState, + } +} + // IngressTLSArrayInput is an input type that accepts IngressTLSArray and IngressTLSArrayOutput values. // You can construct a concrete instance of `IngressTLSArrayInput` via: // @@ -8374,6 +9557,12 @@ func (i IngressTLSArray) ToIngressTLSArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressTLSArrayOutput) } +func (i IngressTLSArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLS] { + return pulumix.Output[[]IngressTLS]{ + OutputState: i.ToIngressTLSArrayOutputWithContext(ctx).OutputState, + } +} + // IngressTLS describes the transport layer security associated with an Ingress. type IngressTLSOutput struct{ *pulumi.OutputState } @@ -8389,6 +9578,12 @@ func (o IngressTLSOutput) ToIngressTLSOutputWithContext(ctx context.Context) Ing return o } +func (o IngressTLSOutput) ToOutput(ctx context.Context) pulumix.Output[IngressTLS] { + return pulumix.Output[IngressTLS]{ + OutputState: o.OutputState, + } +} + // Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. func (o IngressTLSOutput) Hosts() pulumi.StringArrayOutput { return o.ApplyT(func(v IngressTLS) []string { return v.Hosts }).(pulumi.StringArrayOutput) @@ -8413,6 +9608,12 @@ func (o IngressTLSArrayOutput) ToIngressTLSArrayOutputWithContext(ctx context.Co return o } +func (o IngressTLSArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLS] { + return pulumix.Output[[]IngressTLS]{ + OutputState: o.OutputState, + } +} + func (o IngressTLSArrayOutput) Index(i pulumi.IntInput) IngressTLSOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressTLS { return vs[0].([]IngressTLS)[vs[1].(int)] @@ -8458,6 +9659,12 @@ func (i IngressTLSPatchArgs) ToIngressTLSPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressTLSPatchOutput) } +func (i IngressTLSPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressTLSPatch] { + return pulumix.Output[IngressTLSPatch]{ + OutputState: i.ToIngressTLSPatchOutputWithContext(ctx).OutputState, + } +} + // IngressTLSPatchArrayInput is an input type that accepts IngressTLSPatchArray and IngressTLSPatchArrayOutput values. // You can construct a concrete instance of `IngressTLSPatchArrayInput` via: // @@ -8483,6 +9690,12 @@ func (i IngressTLSPatchArray) ToIngressTLSPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressTLSPatchArrayOutput) } +func (i IngressTLSPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLSPatch] { + return pulumix.Output[[]IngressTLSPatch]{ + OutputState: i.ToIngressTLSPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressTLS describes the transport layer security associated with an Ingress. type IngressTLSPatchOutput struct{ *pulumi.OutputState } @@ -8498,6 +9711,12 @@ func (o IngressTLSPatchOutput) ToIngressTLSPatchOutputWithContext(ctx context.Co return o } +func (o IngressTLSPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressTLSPatch] { + return pulumix.Output[IngressTLSPatch]{ + OutputState: o.OutputState, + } +} + // Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. func (o IngressTLSPatchOutput) Hosts() pulumi.StringArrayOutput { return o.ApplyT(func(v IngressTLSPatch) []string { return v.Hosts }).(pulumi.StringArrayOutput) @@ -8522,6 +9741,12 @@ func (o IngressTLSPatchArrayOutput) ToIngressTLSPatchArrayOutputWithContext(ctx return o } +func (o IngressTLSPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLSPatch] { + return pulumix.Output[[]IngressTLSPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressTLSPatchArrayOutput) Index(i pulumi.IntInput) IngressTLSPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressTLSPatch { return vs[0].([]IngressTLSPatch)[vs[1].(int)] @@ -8575,6 +9800,12 @@ func (i NetworkPolicyTypeArgs) ToNetworkPolicyTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyTypeOutput) } +func (i NetworkPolicyTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyType] { + return pulumix.Output[NetworkPolicyType]{ + OutputState: i.ToNetworkPolicyTypeOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyTypeArrayInput is an input type that accepts NetworkPolicyTypeArray and NetworkPolicyTypeArrayOutput values. // You can construct a concrete instance of `NetworkPolicyTypeArrayInput` via: // @@ -8600,6 +9831,12 @@ func (i NetworkPolicyTypeArray) ToNetworkPolicyTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyTypeArrayOutput) } +func (i NetworkPolicyTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyType] { + return pulumix.Output[[]NetworkPolicyType]{ + OutputState: i.ToNetworkPolicyTypeArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicy is deprecated by networking/v1/NetworkPolicy. NetworkPolicy describes what network traffic is allowed for a set of Pods type NetworkPolicyTypeOutput struct{ *pulumi.OutputState } @@ -8615,6 +9852,12 @@ func (o NetworkPolicyTypeOutput) ToNetworkPolicyTypeOutputWithContext(ctx contex return o } +func (o NetworkPolicyTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyType] { + return pulumix.Output[NetworkPolicyType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NetworkPolicyType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -8649,6 +9892,12 @@ func (o NetworkPolicyTypeArrayOutput) ToNetworkPolicyTypeArrayOutputWithContext( return o } +func (o NetworkPolicyTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyType] { + return pulumix.Output[[]NetworkPolicyType]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyTypeArrayOutput) Index(i pulumi.IntInput) NetworkPolicyTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyType { return vs[0].([]NetworkPolicyType)[vs[1].(int)] @@ -8694,6 +9943,12 @@ func (i NetworkPolicyEgressRuleArgs) ToNetworkPolicyEgressRuleOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRuleOutput) } +func (i NetworkPolicyEgressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRule] { + return pulumix.Output[NetworkPolicyEgressRule]{ + OutputState: i.ToNetworkPolicyEgressRuleOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyEgressRuleArrayInput is an input type that accepts NetworkPolicyEgressRuleArray and NetworkPolicyEgressRuleArrayOutput values. // You can construct a concrete instance of `NetworkPolicyEgressRuleArrayInput` via: // @@ -8719,6 +9974,12 @@ func (i NetworkPolicyEgressRuleArray) ToNetworkPolicyEgressRuleArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRuleArrayOutput) } +func (i NetworkPolicyEgressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRule] { + return pulumix.Output[[]NetworkPolicyEgressRule]{ + OutputState: i.ToNetworkPolicyEgressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyEgressRule is deprecated by networking/v1/NetworkPolicyEgressRule. NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 type NetworkPolicyEgressRuleOutput struct{ *pulumi.OutputState } @@ -8734,6 +9995,12 @@ func (o NetworkPolicyEgressRuleOutput) ToNetworkPolicyEgressRuleOutputWithContex return o } +func (o NetworkPolicyEgressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRule] { + return pulumix.Output[NetworkPolicyEgressRule]{ + OutputState: o.OutputState, + } +} + // List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. func (o NetworkPolicyEgressRuleOutput) Ports() NetworkPolicyPortArrayOutput { return o.ApplyT(func(v NetworkPolicyEgressRule) []NetworkPolicyPort { return v.Ports }).(NetworkPolicyPortArrayOutput) @@ -8758,6 +10025,12 @@ func (o NetworkPolicyEgressRuleArrayOutput) ToNetworkPolicyEgressRuleArrayOutput return o } +func (o NetworkPolicyEgressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRule] { + return pulumix.Output[[]NetworkPolicyEgressRule]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyEgressRuleArrayOutput) Index(i pulumi.IntInput) NetworkPolicyEgressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyEgressRule { return vs[0].([]NetworkPolicyEgressRule)[vs[1].(int)] @@ -8803,6 +10076,12 @@ func (i NetworkPolicyEgressRulePatchArgs) ToNetworkPolicyEgressRulePatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRulePatchOutput) } +func (i NetworkPolicyEgressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRulePatch] { + return pulumix.Output[NetworkPolicyEgressRulePatch]{ + OutputState: i.ToNetworkPolicyEgressRulePatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyEgressRulePatchArrayInput is an input type that accepts NetworkPolicyEgressRulePatchArray and NetworkPolicyEgressRulePatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyEgressRulePatchArrayInput` via: // @@ -8828,6 +10107,12 @@ func (i NetworkPolicyEgressRulePatchArray) ToNetworkPolicyEgressRulePatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRulePatchArrayOutput) } +func (i NetworkPolicyEgressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRulePatch] { + return pulumix.Output[[]NetworkPolicyEgressRulePatch]{ + OutputState: i.ToNetworkPolicyEgressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyEgressRule is deprecated by networking/v1/NetworkPolicyEgressRule. NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 type NetworkPolicyEgressRulePatchOutput struct{ *pulumi.OutputState } @@ -8843,6 +10128,12 @@ func (o NetworkPolicyEgressRulePatchOutput) ToNetworkPolicyEgressRulePatchOutput return o } +func (o NetworkPolicyEgressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRulePatch] { + return pulumix.Output[NetworkPolicyEgressRulePatch]{ + OutputState: o.OutputState, + } +} + // List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. func (o NetworkPolicyEgressRulePatchOutput) Ports() NetworkPolicyPortPatchArrayOutput { return o.ApplyT(func(v NetworkPolicyEgressRulePatch) []NetworkPolicyPortPatch { return v.Ports }).(NetworkPolicyPortPatchArrayOutput) @@ -8867,6 +10158,12 @@ func (o NetworkPolicyEgressRulePatchArrayOutput) ToNetworkPolicyEgressRulePatchA return o } +func (o NetworkPolicyEgressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRulePatch] { + return pulumix.Output[[]NetworkPolicyEgressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyEgressRulePatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyEgressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyEgressRulePatch { return vs[0].([]NetworkPolicyEgressRulePatch)[vs[1].(int)] @@ -8912,6 +10209,12 @@ func (i NetworkPolicyIngressRuleArgs) ToNetworkPolicyIngressRuleOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRuleOutput) } +func (i NetworkPolicyIngressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRule] { + return pulumix.Output[NetworkPolicyIngressRule]{ + OutputState: i.ToNetworkPolicyIngressRuleOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyIngressRuleArrayInput is an input type that accepts NetworkPolicyIngressRuleArray and NetworkPolicyIngressRuleArrayOutput values. // You can construct a concrete instance of `NetworkPolicyIngressRuleArrayInput` via: // @@ -8937,6 +10240,12 @@ func (i NetworkPolicyIngressRuleArray) ToNetworkPolicyIngressRuleArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRuleArrayOutput) } +func (i NetworkPolicyIngressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRule] { + return pulumix.Output[[]NetworkPolicyIngressRule]{ + OutputState: i.ToNetworkPolicyIngressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyIngressRule is deprecated by networking/v1/NetworkPolicyIngressRule. This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from. type NetworkPolicyIngressRuleOutput struct{ *pulumi.OutputState } @@ -8952,6 +10261,12 @@ func (o NetworkPolicyIngressRuleOutput) ToNetworkPolicyIngressRuleOutputWithCont return o } +func (o NetworkPolicyIngressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRule] { + return pulumix.Output[NetworkPolicyIngressRule]{ + OutputState: o.OutputState, + } +} + // List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. func (o NetworkPolicyIngressRuleOutput) From() NetworkPolicyPeerArrayOutput { return o.ApplyT(func(v NetworkPolicyIngressRule) []NetworkPolicyPeer { return v.From }).(NetworkPolicyPeerArrayOutput) @@ -8976,6 +10291,12 @@ func (o NetworkPolicyIngressRuleArrayOutput) ToNetworkPolicyIngressRuleArrayOutp return o } +func (o NetworkPolicyIngressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRule] { + return pulumix.Output[[]NetworkPolicyIngressRule]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyIngressRuleArrayOutput) Index(i pulumi.IntInput) NetworkPolicyIngressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyIngressRule { return vs[0].([]NetworkPolicyIngressRule)[vs[1].(int)] @@ -9021,6 +10342,12 @@ func (i NetworkPolicyIngressRulePatchArgs) ToNetworkPolicyIngressRulePatchOutput return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRulePatchOutput) } +func (i NetworkPolicyIngressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRulePatch] { + return pulumix.Output[NetworkPolicyIngressRulePatch]{ + OutputState: i.ToNetworkPolicyIngressRulePatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyIngressRulePatchArrayInput is an input type that accepts NetworkPolicyIngressRulePatchArray and NetworkPolicyIngressRulePatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyIngressRulePatchArrayInput` via: // @@ -9046,6 +10373,12 @@ func (i NetworkPolicyIngressRulePatchArray) ToNetworkPolicyIngressRulePatchArray return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRulePatchArrayOutput) } +func (i NetworkPolicyIngressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRulePatch] { + return pulumix.Output[[]NetworkPolicyIngressRulePatch]{ + OutputState: i.ToNetworkPolicyIngressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyIngressRule is deprecated by networking/v1/NetworkPolicyIngressRule. This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from. type NetworkPolicyIngressRulePatchOutput struct{ *pulumi.OutputState } @@ -9061,6 +10394,12 @@ func (o NetworkPolicyIngressRulePatchOutput) ToNetworkPolicyIngressRulePatchOutp return o } +func (o NetworkPolicyIngressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRulePatch] { + return pulumix.Output[NetworkPolicyIngressRulePatch]{ + OutputState: o.OutputState, + } +} + // List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. func (o NetworkPolicyIngressRulePatchOutput) From() NetworkPolicyPeerPatchArrayOutput { return o.ApplyT(func(v NetworkPolicyIngressRulePatch) []NetworkPolicyPeerPatch { return v.From }).(NetworkPolicyPeerPatchArrayOutput) @@ -9085,6 +10424,12 @@ func (o NetworkPolicyIngressRulePatchArrayOutput) ToNetworkPolicyIngressRulePatc return o } +func (o NetworkPolicyIngressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRulePatch] { + return pulumix.Output[[]NetworkPolicyIngressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyIngressRulePatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyIngressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyIngressRulePatch { return vs[0].([]NetworkPolicyIngressRulePatch)[vs[1].(int)] @@ -9138,6 +10483,12 @@ func (i NetworkPolicyListTypeArgs) ToNetworkPolicyListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListTypeOutput) } +func (i NetworkPolicyListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyListType] { + return pulumix.Output[NetworkPolicyListType]{ + OutputState: i.ToNetworkPolicyListTypeOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyList is deprecated by networking/v1/NetworkPolicyList. Network Policy List is a list of NetworkPolicy objects. type NetworkPolicyListTypeOutput struct{ *pulumi.OutputState } @@ -9153,6 +10504,12 @@ func (o NetworkPolicyListTypeOutput) ToNetworkPolicyListTypeOutputWithContext(ct return o } +func (o NetworkPolicyListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyListType] { + return pulumix.Output[NetworkPolicyListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NetworkPolicyListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -9220,6 +10577,12 @@ func (i NetworkPolicyPatchTypeArgs) ToNetworkPolicyPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchTypeOutput) } +func (i NetworkPolicyPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPatchType] { + return pulumix.Output[NetworkPolicyPatchType]{ + OutputState: i.ToNetworkPolicyPatchTypeOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicy is deprecated by networking/v1/NetworkPolicy. NetworkPolicy describes what network traffic is allowed for a set of Pods type NetworkPolicyPatchTypeOutput struct{ *pulumi.OutputState } @@ -9235,6 +10598,12 @@ func (o NetworkPolicyPatchTypeOutput) ToNetworkPolicyPatchTypeOutputWithContext( return o } +func (o NetworkPolicyPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPatchType] { + return pulumix.Output[NetworkPolicyPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NetworkPolicyPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -9306,6 +10675,12 @@ func (i NetworkPolicyPeerArgs) ToNetworkPolicyPeerOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerOutput) } +func (i NetworkPolicyPeerArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeer] { + return pulumix.Output[NetworkPolicyPeer]{ + OutputState: i.ToNetworkPolicyPeerOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPeerArrayInput is an input type that accepts NetworkPolicyPeerArray and NetworkPolicyPeerArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPeerArrayInput` via: // @@ -9331,6 +10706,12 @@ func (i NetworkPolicyPeerArray) ToNetworkPolicyPeerArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerArrayOutput) } +func (i NetworkPolicyPeerArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeer] { + return pulumix.Output[[]NetworkPolicyPeer]{ + OutputState: i.ToNetworkPolicyPeerArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyPeer is deprecated by networking/v1/NetworkPolicyPeer. type NetworkPolicyPeerOutput struct{ *pulumi.OutputState } @@ -9346,6 +10727,12 @@ func (o NetworkPolicyPeerOutput) ToNetworkPolicyPeerOutputWithContext(ctx contex return o } +func (o NetworkPolicyPeerOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeer] { + return pulumix.Output[NetworkPolicyPeer]{ + OutputState: o.OutputState, + } +} + // IPBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be. func (o NetworkPolicyPeerOutput) IpBlock() IPBlockPtrOutput { return o.ApplyT(func(v NetworkPolicyPeer) *IPBlock { return v.IpBlock }).(IPBlockPtrOutput) @@ -9379,6 +10766,12 @@ func (o NetworkPolicyPeerArrayOutput) ToNetworkPolicyPeerArrayOutputWithContext( return o } +func (o NetworkPolicyPeerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeer] { + return pulumix.Output[[]NetworkPolicyPeer]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPeerArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPeerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPeer { return vs[0].([]NetworkPolicyPeer)[vs[1].(int)] @@ -9436,6 +10829,12 @@ func (i NetworkPolicyPeerPatchArgs) ToNetworkPolicyPeerPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerPatchOutput) } +func (i NetworkPolicyPeerPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeerPatch] { + return pulumix.Output[NetworkPolicyPeerPatch]{ + OutputState: i.ToNetworkPolicyPeerPatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPeerPatchArrayInput is an input type that accepts NetworkPolicyPeerPatchArray and NetworkPolicyPeerPatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPeerPatchArrayInput` via: // @@ -9461,6 +10860,12 @@ func (i NetworkPolicyPeerPatchArray) ToNetworkPolicyPeerPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerPatchArrayOutput) } +func (i NetworkPolicyPeerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeerPatch] { + return pulumix.Output[[]NetworkPolicyPeerPatch]{ + OutputState: i.ToNetworkPolicyPeerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyPeer is deprecated by networking/v1/NetworkPolicyPeer. type NetworkPolicyPeerPatchOutput struct{ *pulumi.OutputState } @@ -9476,6 +10881,12 @@ func (o NetworkPolicyPeerPatchOutput) ToNetworkPolicyPeerPatchOutputWithContext( return o } +func (o NetworkPolicyPeerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeerPatch] { + return pulumix.Output[NetworkPolicyPeerPatch]{ + OutputState: o.OutputState, + } +} + // IPBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be. func (o NetworkPolicyPeerPatchOutput) IpBlock() IPBlockPatchPtrOutput { return o.ApplyT(func(v NetworkPolicyPeerPatch) *IPBlockPatch { return v.IpBlock }).(IPBlockPatchPtrOutput) @@ -9509,6 +10920,12 @@ func (o NetworkPolicyPeerPatchArrayOutput) ToNetworkPolicyPeerPatchArrayOutputWi return o } +func (o NetworkPolicyPeerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeerPatch] { + return pulumix.Output[[]NetworkPolicyPeerPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPeerPatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPeerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPeerPatch { return vs[0].([]NetworkPolicyPeerPatch)[vs[1].(int)] @@ -9554,6 +10971,12 @@ func (i NetworkPolicyPortArgs) ToNetworkPolicyPortOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortOutput) } +func (i NetworkPolicyPortArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPort] { + return pulumix.Output[NetworkPolicyPort]{ + OutputState: i.ToNetworkPolicyPortOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPortArrayInput is an input type that accepts NetworkPolicyPortArray and NetworkPolicyPortArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPortArrayInput` via: // @@ -9579,6 +11002,12 @@ func (i NetworkPolicyPortArray) ToNetworkPolicyPortArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortArrayOutput) } +func (i NetworkPolicyPortArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPort] { + return pulumix.Output[[]NetworkPolicyPort]{ + OutputState: i.ToNetworkPolicyPortArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyPort is deprecated by networking/v1/NetworkPolicyPort. type NetworkPolicyPortOutput struct{ *pulumi.OutputState } @@ -9594,6 +11023,12 @@ func (o NetworkPolicyPortOutput) ToNetworkPolicyPortOutputWithContext(ctx contex return o } +func (o NetworkPolicyPortOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPort] { + return pulumix.Output[NetworkPolicyPort]{ + OutputState: o.OutputState, + } +} + // If specified, the port on the given protocol. This can either be a numerical or named port on a pod. If this field is not provided, this matches all port names and numbers. If present, only traffic on the specified protocol AND port will be matched. func (o NetworkPolicyPortOutput) Port() pulumi.AnyOutput { return o.ApplyT(func(v NetworkPolicyPort) interface{} { return v.Port }).(pulumi.AnyOutput) @@ -9618,6 +11053,12 @@ func (o NetworkPolicyPortArrayOutput) ToNetworkPolicyPortArrayOutputWithContext( return o } +func (o NetworkPolicyPortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPort] { + return pulumix.Output[[]NetworkPolicyPort]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPortArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPort { return vs[0].([]NetworkPolicyPort)[vs[1].(int)] @@ -9663,6 +11104,12 @@ func (i NetworkPolicyPortPatchArgs) ToNetworkPolicyPortPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortPatchOutput) } +func (i NetworkPolicyPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPortPatch] { + return pulumix.Output[NetworkPolicyPortPatch]{ + OutputState: i.ToNetworkPolicyPortPatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPortPatchArrayInput is an input type that accepts NetworkPolicyPortPatchArray and NetworkPolicyPortPatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPortPatchArrayInput` via: // @@ -9688,6 +11135,12 @@ func (i NetworkPolicyPortPatchArray) ToNetworkPolicyPortPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortPatchArrayOutput) } +func (i NetworkPolicyPortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPortPatch] { + return pulumix.Output[[]NetworkPolicyPortPatch]{ + OutputState: i.ToNetworkPolicyPortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicyPort is deprecated by networking/v1/NetworkPolicyPort. type NetworkPolicyPortPatchOutput struct{ *pulumi.OutputState } @@ -9703,6 +11156,12 @@ func (o NetworkPolicyPortPatchOutput) ToNetworkPolicyPortPatchOutputWithContext( return o } +func (o NetworkPolicyPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPortPatch] { + return pulumix.Output[NetworkPolicyPortPatch]{ + OutputState: o.OutputState, + } +} + // If specified, the port on the given protocol. This can either be a numerical or named port on a pod. If this field is not provided, this matches all port names and numbers. If present, only traffic on the specified protocol AND port will be matched. func (o NetworkPolicyPortPatchOutput) Port() pulumi.AnyOutput { return o.ApplyT(func(v NetworkPolicyPortPatch) interface{} { return v.Port }).(pulumi.AnyOutput) @@ -9727,6 +11186,12 @@ func (o NetworkPolicyPortPatchArrayOutput) ToNetworkPolicyPortPatchArrayOutputWi return o } +func (o NetworkPolicyPortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPortPatch] { + return pulumix.Output[[]NetworkPolicyPortPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPortPatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPortPatch { return vs[0].([]NetworkPolicyPortPatch)[vs[1].(int)] @@ -9780,6 +11245,12 @@ func (i NetworkPolicySpecArgs) ToNetworkPolicySpecOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecOutput) } +func (i NetworkPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpec] { + return pulumix.Output[NetworkPolicySpec]{ + OutputState: i.ToNetworkPolicySpecOutputWithContext(ctx).OutputState, + } +} + func (i NetworkPolicySpecArgs) ToNetworkPolicySpecPtrOutput() NetworkPolicySpecPtrOutput { return i.ToNetworkPolicySpecPtrOutputWithContext(context.Background()) } @@ -9821,6 +11292,12 @@ func (i *networkPolicySpecPtrType) ToNetworkPolicySpecPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecPtrOutput) } +func (i *networkPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpec] { + return pulumix.Output[*NetworkPolicySpec]{ + OutputState: i.ToNetworkPolicySpecPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicySpec is deprecated by networking/v1/NetworkPolicySpec. type NetworkPolicySpecOutput struct{ *pulumi.OutputState } @@ -9846,6 +11323,12 @@ func (o NetworkPolicySpecOutput) ToNetworkPolicySpecPtrOutputWithContext(ctx con }).(NetworkPolicySpecPtrOutput) } +func (o NetworkPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpec] { + return pulumix.Output[NetworkPolicySpec]{ + OutputState: o.OutputState, + } +} + // List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 func (o NetworkPolicySpecOutput) Egress() NetworkPolicyEgressRuleArrayOutput { return o.ApplyT(func(v NetworkPolicySpec) []NetworkPolicyEgressRule { return v.Egress }).(NetworkPolicyEgressRuleArrayOutput) @@ -9880,6 +11363,12 @@ func (o NetworkPolicySpecPtrOutput) ToNetworkPolicySpecPtrOutputWithContext(ctx return o } +func (o NetworkPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpec] { + return pulumix.Output[*NetworkPolicySpec]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicySpecPtrOutput) Elem() NetworkPolicySpecOutput { return o.ApplyT(func(v *NetworkPolicySpec) NetworkPolicySpec { if v != nil { @@ -9977,6 +11466,12 @@ func (i NetworkPolicySpecPatchArgs) ToNetworkPolicySpecPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecPatchOutput) } +func (i NetworkPolicySpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpecPatch] { + return pulumix.Output[NetworkPolicySpecPatch]{ + OutputState: i.ToNetworkPolicySpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i NetworkPolicySpecPatchArgs) ToNetworkPolicySpecPatchPtrOutput() NetworkPolicySpecPatchPtrOutput { return i.ToNetworkPolicySpecPatchPtrOutputWithContext(context.Background()) } @@ -10018,6 +11513,12 @@ func (i *networkPolicySpecPatchPtrType) ToNetworkPolicySpecPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecPatchPtrOutput) } +func (i *networkPolicySpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpecPatch] { + return pulumix.Output[*NetworkPolicySpecPatch]{ + OutputState: i.ToNetworkPolicySpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED 1.9 - This group version of NetworkPolicySpec is deprecated by networking/v1/NetworkPolicySpec. type NetworkPolicySpecPatchOutput struct{ *pulumi.OutputState } @@ -10043,6 +11544,12 @@ func (o NetworkPolicySpecPatchOutput) ToNetworkPolicySpecPatchPtrOutputWithConte }).(NetworkPolicySpecPatchPtrOutput) } +func (o NetworkPolicySpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpecPatch] { + return pulumix.Output[NetworkPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + // List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 func (o NetworkPolicySpecPatchOutput) Egress() NetworkPolicyEgressRulePatchArrayOutput { return o.ApplyT(func(v NetworkPolicySpecPatch) []NetworkPolicyEgressRulePatch { return v.Egress }).(NetworkPolicyEgressRulePatchArrayOutput) @@ -10077,6 +11584,12 @@ func (o NetworkPolicySpecPatchPtrOutput) ToNetworkPolicySpecPatchPtrOutputWithCo return o } +func (o NetworkPolicySpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpecPatch] { + return pulumix.Output[*NetworkPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicySpecPatchPtrOutput) Elem() NetworkPolicySpecPatchOutput { return o.ApplyT(func(v *NetworkPolicySpecPatch) NetworkPolicySpecPatch { if v != nil { @@ -10174,6 +11687,12 @@ func (i PodSecurityPolicyTypeArgs) ToPodSecurityPolicyTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyTypeOutput) } +func (i PodSecurityPolicyTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyType] { + return pulumix.Output[PodSecurityPolicyType]{ + OutputState: i.ToPodSecurityPolicyTypeOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyTypeArrayInput is an input type that accepts PodSecurityPolicyTypeArray and PodSecurityPolicyTypeArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyTypeArrayInput` via: // @@ -10199,6 +11718,12 @@ func (i PodSecurityPolicyTypeArray) ToPodSecurityPolicyTypeArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyTypeArrayOutput) } +func (i PodSecurityPolicyTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodSecurityPolicyType] { + return pulumix.Output[[]PodSecurityPolicyType]{ + OutputState: i.ToPodSecurityPolicyTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. Deprecated: use PodSecurityPolicy from policy API Group instead. type PodSecurityPolicyTypeOutput struct{ *pulumi.OutputState } @@ -10214,6 +11739,12 @@ func (o PodSecurityPolicyTypeOutput) ToPodSecurityPolicyTypeOutputWithContext(ct return o } +func (o PodSecurityPolicyTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyType] { + return pulumix.Output[PodSecurityPolicyType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSecurityPolicyType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -10248,6 +11779,12 @@ func (o PodSecurityPolicyTypeArrayOutput) ToPodSecurityPolicyTypeArrayOutputWith return o } +func (o PodSecurityPolicyTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodSecurityPolicyType] { + return pulumix.Output[[]PodSecurityPolicyType]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyTypeArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodSecurityPolicyType { return vs[0].([]PodSecurityPolicyType)[vs[1].(int)] @@ -10301,6 +11838,12 @@ func (i PodSecurityPolicyListTypeArgs) ToPodSecurityPolicyListTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListTypeOutput) } +func (i PodSecurityPolicyListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyListType] { + return pulumix.Output[PodSecurityPolicyListType]{ + OutputState: i.ToPodSecurityPolicyListTypeOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyList is a list of PodSecurityPolicy objects. Deprecated: use PodSecurityPolicyList from policy API Group instead. type PodSecurityPolicyListTypeOutput struct{ *pulumi.OutputState } @@ -10316,6 +11859,12 @@ func (o PodSecurityPolicyListTypeOutput) ToPodSecurityPolicyListTypeOutputWithCo return o } +func (o PodSecurityPolicyListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyListType] { + return pulumix.Output[PodSecurityPolicyListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSecurityPolicyListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -10383,6 +11932,12 @@ func (i PodSecurityPolicyPatchTypeArgs) ToPodSecurityPolicyPatchTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchTypeOutput) } +func (i PodSecurityPolicyPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyPatchType] { + return pulumix.Output[PodSecurityPolicyPatchType]{ + OutputState: i.ToPodSecurityPolicyPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. Deprecated: use PodSecurityPolicy from policy API Group instead. type PodSecurityPolicyPatchTypeOutput struct{ *pulumi.OutputState } @@ -10398,6 +11953,12 @@ func (o PodSecurityPolicyPatchTypeOutput) ToPodSecurityPolicyPatchTypeOutputWith return o } +func (o PodSecurityPolicyPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyPatchType] { + return pulumix.Output[PodSecurityPolicyPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSecurityPolicyPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -10553,6 +12114,12 @@ func (i PodSecurityPolicySpecArgs) ToPodSecurityPolicySpecOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecOutput) } +func (i PodSecurityPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpec] { + return pulumix.Output[PodSecurityPolicySpec]{ + OutputState: i.ToPodSecurityPolicySpecOutputWithContext(ctx).OutputState, + } +} + func (i PodSecurityPolicySpecArgs) ToPodSecurityPolicySpecPtrOutput() PodSecurityPolicySpecPtrOutput { return i.ToPodSecurityPolicySpecPtrOutputWithContext(context.Background()) } @@ -10594,6 +12161,12 @@ func (i *podSecurityPolicySpecPtrType) ToPodSecurityPolicySpecPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecPtrOutput) } +func (i *podSecurityPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpec] { + return pulumix.Output[*PodSecurityPolicySpec]{ + OutputState: i.ToPodSecurityPolicySpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicySpec defines the policy enforced. Deprecated: use PodSecurityPolicySpec from policy API Group instead. type PodSecurityPolicySpecOutput struct{ *pulumi.OutputState } @@ -10619,6 +12192,12 @@ func (o PodSecurityPolicySpecOutput) ToPodSecurityPolicySpecPtrOutputWithContext }).(PodSecurityPolicySpecPtrOutput) } +func (o PodSecurityPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpec] { + return pulumix.Output[PodSecurityPolicySpec]{ + OutputState: o.OutputState, + } +} + // allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. func (o PodSecurityPolicySpecOutput) AllowPrivilegeEscalation() pulumi.BoolPtrOutput { return o.ApplyT(func(v PodSecurityPolicySpec) *bool { return v.AllowPrivilegeEscalation }).(pulumi.BoolPtrOutput) @@ -10757,6 +12336,12 @@ func (o PodSecurityPolicySpecPtrOutput) ToPodSecurityPolicySpecPtrOutputWithCont return o } +func (o PodSecurityPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpec] { + return pulumix.Output[*PodSecurityPolicySpec]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicySpecPtrOutput) Elem() PodSecurityPolicySpecOutput { return o.ApplyT(func(v *PodSecurityPolicySpec) PodSecurityPolicySpec { if v != nil { @@ -11146,6 +12731,12 @@ func (i PodSecurityPolicySpecPatchArgs) ToPodSecurityPolicySpecPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecPatchOutput) } +func (i PodSecurityPolicySpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpecPatch] { + return pulumix.Output[PodSecurityPolicySpecPatch]{ + OutputState: i.ToPodSecurityPolicySpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSecurityPolicySpecPatchArgs) ToPodSecurityPolicySpecPatchPtrOutput() PodSecurityPolicySpecPatchPtrOutput { return i.ToPodSecurityPolicySpecPatchPtrOutputWithContext(context.Background()) } @@ -11187,6 +12778,12 @@ func (i *podSecurityPolicySpecPatchPtrType) ToPodSecurityPolicySpecPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecPatchPtrOutput) } +func (i *podSecurityPolicySpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpecPatch] { + return pulumix.Output[*PodSecurityPolicySpecPatch]{ + OutputState: i.ToPodSecurityPolicySpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicySpec defines the policy enforced. Deprecated: use PodSecurityPolicySpec from policy API Group instead. type PodSecurityPolicySpecPatchOutput struct{ *pulumi.OutputState } @@ -11212,6 +12809,12 @@ func (o PodSecurityPolicySpecPatchOutput) ToPodSecurityPolicySpecPatchPtrOutputW }).(PodSecurityPolicySpecPatchPtrOutput) } +func (o PodSecurityPolicySpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpecPatch] { + return pulumix.Output[PodSecurityPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + // allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. func (o PodSecurityPolicySpecPatchOutput) AllowPrivilegeEscalation() pulumi.BoolPtrOutput { return o.ApplyT(func(v PodSecurityPolicySpecPatch) *bool { return v.AllowPrivilegeEscalation }).(pulumi.BoolPtrOutput) @@ -11352,6 +12955,12 @@ func (o PodSecurityPolicySpecPatchPtrOutput) ToPodSecurityPolicySpecPatchPtrOutp return o } +func (o PodSecurityPolicySpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpecPatch] { + return pulumix.Output[*PodSecurityPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicySpecPatchPtrOutput) Elem() PodSecurityPolicySpecPatchOutput { return o.ApplyT(func(v *PodSecurityPolicySpecPatch) PodSecurityPolicySpecPatch { if v != nil { @@ -11657,6 +13266,12 @@ func (i ReplicaSetTypeArgs) ToReplicaSetTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetTypeOutput) } +func (i ReplicaSetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetType] { + return pulumix.Output[ReplicaSetType]{ + OutputState: i.ToReplicaSetTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetTypeArrayInput is an input type that accepts ReplicaSetTypeArray and ReplicaSetTypeArrayOutput values. // You can construct a concrete instance of `ReplicaSetTypeArrayInput` via: // @@ -11682,6 +13297,12 @@ func (i ReplicaSetTypeArray) ToReplicaSetTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetTypeArrayOutput) } +func (i ReplicaSetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetType] { + return pulumix.Output[[]ReplicaSetType]{ + OutputState: i.ToReplicaSetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSet ensures that a specified number of pod replicas are running at any given time. type ReplicaSetTypeOutput struct{ *pulumi.OutputState } @@ -11697,6 +13318,12 @@ func (o ReplicaSetTypeOutput) ToReplicaSetTypeOutputWithContext(ctx context.Cont return o } +func (o ReplicaSetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetType] { + return pulumix.Output[ReplicaSetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -11736,6 +13363,12 @@ func (o ReplicaSetTypeArrayOutput) ToReplicaSetTypeArrayOutputWithContext(ctx co return o } +func (o ReplicaSetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetType] { + return pulumix.Output[[]ReplicaSetType]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetTypeArrayOutput) Index(i pulumi.IntInput) ReplicaSetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetType { return vs[0].([]ReplicaSetType)[vs[1].(int)] @@ -11793,6 +13426,12 @@ func (i ReplicaSetConditionArgs) ToReplicaSetConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionOutput) } +func (i ReplicaSetConditionArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetCondition] { + return pulumix.Output[ReplicaSetCondition]{ + OutputState: i.ToReplicaSetConditionOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetConditionArrayInput is an input type that accepts ReplicaSetConditionArray and ReplicaSetConditionArrayOutput values. // You can construct a concrete instance of `ReplicaSetConditionArrayInput` via: // @@ -11818,6 +13457,12 @@ func (i ReplicaSetConditionArray) ToReplicaSetConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionArrayOutput) } +func (i ReplicaSetConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetCondition] { + return pulumix.Output[[]ReplicaSetCondition]{ + OutputState: i.ToReplicaSetConditionArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetCondition describes the state of a replica set at a certain point. type ReplicaSetConditionOutput struct{ *pulumi.OutputState } @@ -11833,6 +13478,12 @@ func (o ReplicaSetConditionOutput) ToReplicaSetConditionOutputWithContext(ctx co return o } +func (o ReplicaSetConditionOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetCondition] { + return pulumix.Output[ReplicaSetCondition]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicaSetConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -11872,6 +13523,12 @@ func (o ReplicaSetConditionArrayOutput) ToReplicaSetConditionArrayOutputWithCont return o } +func (o ReplicaSetConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetCondition] { + return pulumix.Output[[]ReplicaSetCondition]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetConditionArrayOutput) Index(i pulumi.IntInput) ReplicaSetConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetCondition { return vs[0].([]ReplicaSetCondition)[vs[1].(int)] @@ -11929,6 +13586,12 @@ func (i ReplicaSetConditionPatchArgs) ToReplicaSetConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionPatchOutput) } +func (i ReplicaSetConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetConditionPatch] { + return pulumix.Output[ReplicaSetConditionPatch]{ + OutputState: i.ToReplicaSetConditionPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetConditionPatchArrayInput is an input type that accepts ReplicaSetConditionPatchArray and ReplicaSetConditionPatchArrayOutput values. // You can construct a concrete instance of `ReplicaSetConditionPatchArrayInput` via: // @@ -11954,6 +13617,12 @@ func (i ReplicaSetConditionPatchArray) ToReplicaSetConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetConditionPatchArrayOutput) } +func (i ReplicaSetConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetConditionPatch] { + return pulumix.Output[[]ReplicaSetConditionPatch]{ + OutputState: i.ToReplicaSetConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetCondition describes the state of a replica set at a certain point. type ReplicaSetConditionPatchOutput struct{ *pulumi.OutputState } @@ -11969,6 +13638,12 @@ func (o ReplicaSetConditionPatchOutput) ToReplicaSetConditionPatchOutputWithCont return o } +func (o ReplicaSetConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetConditionPatch] { + return pulumix.Output[ReplicaSetConditionPatch]{ + OutputState: o.OutputState, + } +} + // The last time the condition transitioned from one status to another. func (o ReplicaSetConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -12008,6 +13683,12 @@ func (o ReplicaSetConditionPatchArrayOutput) ToReplicaSetConditionPatchArrayOutp return o } +func (o ReplicaSetConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ReplicaSetConditionPatch] { + return pulumix.Output[[]ReplicaSetConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetConditionPatchArrayOutput) Index(i pulumi.IntInput) ReplicaSetConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicaSetConditionPatch { return vs[0].([]ReplicaSetConditionPatch)[vs[1].(int)] @@ -12061,6 +13742,12 @@ func (i ReplicaSetListTypeArgs) ToReplicaSetListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListTypeOutput) } +func (i ReplicaSetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetListType] { + return pulumix.Output[ReplicaSetListType]{ + OutputState: i.ToReplicaSetListTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetList is a collection of ReplicaSets. type ReplicaSetListTypeOutput struct{ *pulumi.OutputState } @@ -12076,6 +13763,12 @@ func (o ReplicaSetListTypeOutput) ToReplicaSetListTypeOutputWithContext(ctx cont return o } +func (o ReplicaSetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetListType] { + return pulumix.Output[ReplicaSetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -12147,6 +13840,12 @@ func (i ReplicaSetPatchTypeArgs) ToReplicaSetPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchTypeOutput) } +func (i ReplicaSetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetPatchType] { + return pulumix.Output[ReplicaSetPatchType]{ + OutputState: i.ToReplicaSetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ReplicaSet ensures that a specified number of pod replicas are running at any given time. type ReplicaSetPatchTypeOutput struct{ *pulumi.OutputState } @@ -12162,6 +13861,12 @@ func (o ReplicaSetPatchTypeOutput) ToReplicaSetPatchTypeOutputWithContext(ctx co return o } +func (o ReplicaSetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetPatchType] { + return pulumix.Output[ReplicaSetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReplicaSetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -12234,6 +13939,12 @@ func (i ReplicaSetSpecArgs) ToReplicaSetSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecOutput) } +func (i ReplicaSetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpec] { + return pulumix.Output[ReplicaSetSpec]{ + OutputState: i.ToReplicaSetSpecOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetSpecArgs) ToReplicaSetSpecPtrOutput() ReplicaSetSpecPtrOutput { return i.ToReplicaSetSpecPtrOutputWithContext(context.Background()) } @@ -12275,6 +13986,12 @@ func (i *replicaSetSpecPtrType) ToReplicaSetSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPtrOutput) } +func (i *replicaSetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpec] { + return pulumix.Output[*ReplicaSetSpec]{ + OutputState: i.ToReplicaSetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetSpec is the specification of a ReplicaSet. type ReplicaSetSpecOutput struct{ *pulumi.OutputState } @@ -12300,6 +14017,12 @@ func (o ReplicaSetSpecOutput) ToReplicaSetSpecPtrOutputWithContext(ctx context.C }).(ReplicaSetSpecPtrOutput) } +func (o ReplicaSetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpec] { + return pulumix.Output[ReplicaSetSpec]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicaSetSpecOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetSpec) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -12334,6 +14057,12 @@ func (o ReplicaSetSpecPtrOutput) ToReplicaSetSpecPtrOutputWithContext(ctx contex return o } +func (o ReplicaSetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpec] { + return pulumix.Output[*ReplicaSetSpec]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetSpecPtrOutput) Elem() ReplicaSetSpecOutput { return o.ApplyT(func(v *ReplicaSetSpec) ReplicaSetSpec { if v != nil { @@ -12431,6 +14160,12 @@ func (i ReplicaSetSpecPatchArgs) ToReplicaSetSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPatchOutput) } +func (i ReplicaSetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpecPatch] { + return pulumix.Output[ReplicaSetSpecPatch]{ + OutputState: i.ToReplicaSetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetSpecPatchArgs) ToReplicaSetSpecPatchPtrOutput() ReplicaSetSpecPatchPtrOutput { return i.ToReplicaSetSpecPatchPtrOutputWithContext(context.Background()) } @@ -12472,6 +14207,12 @@ func (i *replicaSetSpecPatchPtrType) ToReplicaSetSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetSpecPatchPtrOutput) } +func (i *replicaSetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpecPatch] { + return pulumix.Output[*ReplicaSetSpecPatch]{ + OutputState: i.ToReplicaSetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetSpec is the specification of a ReplicaSet. type ReplicaSetSpecPatchOutput struct{ *pulumi.OutputState } @@ -12497,6 +14238,12 @@ func (o ReplicaSetSpecPatchOutput) ToReplicaSetSpecPatchPtrOutputWithContext(ctx }).(ReplicaSetSpecPatchPtrOutput) } +func (o ReplicaSetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetSpecPatch] { + return pulumix.Output[ReplicaSetSpecPatch]{ + OutputState: o.OutputState, + } +} + // Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) func (o ReplicaSetSpecPatchOutput) MinReadySeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetSpecPatch) *int { return v.MinReadySeconds }).(pulumi.IntPtrOutput) @@ -12531,6 +14278,12 @@ func (o ReplicaSetSpecPatchPtrOutput) ToReplicaSetSpecPatchPtrOutputWithContext( return o } +func (o ReplicaSetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetSpecPatch] { + return pulumix.Output[*ReplicaSetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetSpecPatchPtrOutput) Elem() ReplicaSetSpecPatchOutput { return o.ApplyT(func(v *ReplicaSetSpecPatch) ReplicaSetSpecPatch { if v != nil { @@ -12636,6 +14389,12 @@ func (i ReplicaSetStatusArgs) ToReplicaSetStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusOutput) } +func (i ReplicaSetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatus] { + return pulumix.Output[ReplicaSetStatus]{ + OutputState: i.ToReplicaSetStatusOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetStatusArgs) ToReplicaSetStatusPtrOutput() ReplicaSetStatusPtrOutput { return i.ToReplicaSetStatusPtrOutputWithContext(context.Background()) } @@ -12677,6 +14436,12 @@ func (i *replicaSetStatusPtrType) ToReplicaSetStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPtrOutput) } +func (i *replicaSetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatus] { + return pulumix.Output[*ReplicaSetStatus]{ + OutputState: i.ToReplicaSetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetStatus represents the current status of a ReplicaSet. type ReplicaSetStatusOutput struct{ *pulumi.OutputState } @@ -12702,6 +14467,12 @@ func (o ReplicaSetStatusOutput) ToReplicaSetStatusPtrOutputWithContext(ctx conte }).(ReplicaSetStatusPtrOutput) } +func (o ReplicaSetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatus] { + return pulumix.Output[ReplicaSetStatus]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replica set. func (o ReplicaSetStatusOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetStatus) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -12746,6 +14517,12 @@ func (o ReplicaSetStatusPtrOutput) ToReplicaSetStatusPtrOutputWithContext(ctx co return o } +func (o ReplicaSetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatus] { + return pulumix.Output[*ReplicaSetStatus]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetStatusPtrOutput) Elem() ReplicaSetStatusOutput { return o.ApplyT(func(v *ReplicaSetStatus) ReplicaSetStatus { if v != nil { @@ -12871,6 +14648,12 @@ func (i ReplicaSetStatusPatchArgs) ToReplicaSetStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPatchOutput) } +func (i ReplicaSetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatusPatch] { + return pulumix.Output[ReplicaSetStatusPatch]{ + OutputState: i.ToReplicaSetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ReplicaSetStatusPatchArgs) ToReplicaSetStatusPatchPtrOutput() ReplicaSetStatusPatchPtrOutput { return i.ToReplicaSetStatusPatchPtrOutputWithContext(context.Background()) } @@ -12912,6 +14695,12 @@ func (i *replicaSetStatusPatchPtrType) ToReplicaSetStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetStatusPatchPtrOutput) } +func (i *replicaSetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatusPatch] { + return pulumix.Output[*ReplicaSetStatusPatch]{ + OutputState: i.ToReplicaSetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetStatus represents the current status of a ReplicaSet. type ReplicaSetStatusPatchOutput struct{ *pulumi.OutputState } @@ -12937,6 +14726,12 @@ func (o ReplicaSetStatusPatchOutput) ToReplicaSetStatusPatchPtrOutputWithContext }).(ReplicaSetStatusPatchPtrOutput) } +func (o ReplicaSetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ReplicaSetStatusPatch] { + return pulumix.Output[ReplicaSetStatusPatch]{ + OutputState: o.OutputState, + } +} + // The number of available replicas (ready for at least minReadySeconds) for this replica set. func (o ReplicaSetStatusPatchOutput) AvailableReplicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ReplicaSetStatusPatch) *int { return v.AvailableReplicas }).(pulumi.IntPtrOutput) @@ -12981,6 +14776,12 @@ func (o ReplicaSetStatusPatchPtrOutput) ToReplicaSetStatusPatchPtrOutputWithCont return o } +func (o ReplicaSetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetStatusPatch] { + return pulumix.Output[*ReplicaSetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetStatusPatchPtrOutput) Elem() ReplicaSetStatusPatchOutput { return o.ApplyT(func(v *ReplicaSetStatusPatch) ReplicaSetStatusPatch { if v != nil { @@ -13086,6 +14887,12 @@ func (i RollbackConfigArgs) ToRollbackConfigOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigOutput) } +func (i RollbackConfigArgs) ToOutput(ctx context.Context) pulumix.Output[RollbackConfig] { + return pulumix.Output[RollbackConfig]{ + OutputState: i.ToRollbackConfigOutputWithContext(ctx).OutputState, + } +} + func (i RollbackConfigArgs) ToRollbackConfigPtrOutput() RollbackConfigPtrOutput { return i.ToRollbackConfigPtrOutputWithContext(context.Background()) } @@ -13127,6 +14934,12 @@ func (i *rollbackConfigPtrType) ToRollbackConfigPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigPtrOutput) } +func (i *rollbackConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfig] { + return pulumix.Output[*RollbackConfig]{ + OutputState: i.ToRollbackConfigPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. type RollbackConfigOutput struct{ *pulumi.OutputState } @@ -13152,6 +14965,12 @@ func (o RollbackConfigOutput) ToRollbackConfigPtrOutputWithContext(ctx context.C }).(RollbackConfigPtrOutput) } +func (o RollbackConfigOutput) ToOutput(ctx context.Context) pulumix.Output[RollbackConfig] { + return pulumix.Output[RollbackConfig]{ + OutputState: o.OutputState, + } +} + // The revision to rollback to. If set to 0, rollback to the last revision. func (o RollbackConfigOutput) Revision() pulumi.IntPtrOutput { return o.ApplyT(func(v RollbackConfig) *int { return v.Revision }).(pulumi.IntPtrOutput) @@ -13171,6 +14990,12 @@ func (o RollbackConfigPtrOutput) ToRollbackConfigPtrOutputWithContext(ctx contex return o } +func (o RollbackConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfig] { + return pulumix.Output[*RollbackConfig]{ + OutputState: o.OutputState, + } +} + func (o RollbackConfigPtrOutput) Elem() RollbackConfigOutput { return o.ApplyT(func(v *RollbackConfig) RollbackConfig { if v != nil { @@ -13226,6 +15051,12 @@ func (i RollbackConfigPatchArgs) ToRollbackConfigPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigPatchOutput) } +func (i RollbackConfigPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollbackConfigPatch] { + return pulumix.Output[RollbackConfigPatch]{ + OutputState: i.ToRollbackConfigPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollbackConfigPatchArgs) ToRollbackConfigPatchPtrOutput() RollbackConfigPatchPtrOutput { return i.ToRollbackConfigPatchPtrOutputWithContext(context.Background()) } @@ -13267,6 +15098,12 @@ func (i *rollbackConfigPatchPtrType) ToRollbackConfigPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(RollbackConfigPatchPtrOutput) } +func (i *rollbackConfigPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfigPatch] { + return pulumix.Output[*RollbackConfigPatch]{ + OutputState: i.ToRollbackConfigPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED. type RollbackConfigPatchOutput struct{ *pulumi.OutputState } @@ -13292,6 +15129,12 @@ func (o RollbackConfigPatchOutput) ToRollbackConfigPatchPtrOutputWithContext(ctx }).(RollbackConfigPatchPtrOutput) } +func (o RollbackConfigPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollbackConfigPatch] { + return pulumix.Output[RollbackConfigPatch]{ + OutputState: o.OutputState, + } +} + // The revision to rollback to. If set to 0, rollback to the last revision. func (o RollbackConfigPatchOutput) Revision() pulumi.IntPtrOutput { return o.ApplyT(func(v RollbackConfigPatch) *int { return v.Revision }).(pulumi.IntPtrOutput) @@ -13311,6 +15154,12 @@ func (o RollbackConfigPatchPtrOutput) ToRollbackConfigPatchPtrOutputWithContext( return o } +func (o RollbackConfigPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollbackConfigPatch] { + return pulumix.Output[*RollbackConfigPatch]{ + OutputState: o.OutputState, + } +} + func (o RollbackConfigPatchPtrOutput) Elem() RollbackConfigPatchOutput { return o.ApplyT(func(v *RollbackConfigPatch) RollbackConfigPatch { if v != nil { @@ -13366,6 +15215,12 @@ func (i RollingUpdateDaemonSetArgs) ToRollingUpdateDaemonSetOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetOutput) } +func (i RollingUpdateDaemonSetArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSet] { + return pulumix.Output[RollingUpdateDaemonSet]{ + OutputState: i.ToRollingUpdateDaemonSetOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDaemonSetArgs) ToRollingUpdateDaemonSetPtrOutput() RollingUpdateDaemonSetPtrOutput { return i.ToRollingUpdateDaemonSetPtrOutputWithContext(context.Background()) } @@ -13407,6 +15262,12 @@ func (i *rollingUpdateDaemonSetPtrType) ToRollingUpdateDaemonSetPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPtrOutput) } +func (i *rollingUpdateDaemonSetPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSet] { + return pulumix.Output[*RollingUpdateDaemonSet]{ + OutputState: i.ToRollingUpdateDaemonSetPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of daemon set rolling update. type RollingUpdateDaemonSetOutput struct{ *pulumi.OutputState } @@ -13432,6 +15293,12 @@ func (o RollingUpdateDaemonSetOutput) ToRollingUpdateDaemonSetPtrOutputWithConte }).(RollingUpdateDaemonSetPtrOutput) } +func (o RollingUpdateDaemonSetOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSet] { + return pulumix.Output[RollingUpdateDaemonSet]{ + OutputState: o.OutputState, + } +} + // The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update. func (o RollingUpdateDaemonSetOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDaemonSet) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -13451,6 +15318,12 @@ func (o RollingUpdateDaemonSetPtrOutput) ToRollingUpdateDaemonSetPtrOutputWithCo return o } +func (o RollingUpdateDaemonSetPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSet] { + return pulumix.Output[*RollingUpdateDaemonSet]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDaemonSetPtrOutput) Elem() RollingUpdateDaemonSetOutput { return o.ApplyT(func(v *RollingUpdateDaemonSet) RollingUpdateDaemonSet { if v != nil { @@ -13506,6 +15379,12 @@ func (i RollingUpdateDaemonSetPatchArgs) ToRollingUpdateDaemonSetPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPatchOutput) } +func (i RollingUpdateDaemonSetPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSetPatch] { + return pulumix.Output[RollingUpdateDaemonSetPatch]{ + OutputState: i.ToRollingUpdateDaemonSetPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDaemonSetPatchArgs) ToRollingUpdateDaemonSetPatchPtrOutput() RollingUpdateDaemonSetPatchPtrOutput { return i.ToRollingUpdateDaemonSetPatchPtrOutputWithContext(context.Background()) } @@ -13547,6 +15426,12 @@ func (i *rollingUpdateDaemonSetPatchPtrType) ToRollingUpdateDaemonSetPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDaemonSetPatchPtrOutput) } +func (i *rollingUpdateDaemonSetPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSetPatch] { + return pulumix.Output[*RollingUpdateDaemonSetPatch]{ + OutputState: i.ToRollingUpdateDaemonSetPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of daemon set rolling update. type RollingUpdateDaemonSetPatchOutput struct{ *pulumi.OutputState } @@ -13572,6 +15457,12 @@ func (o RollingUpdateDaemonSetPatchOutput) ToRollingUpdateDaemonSetPatchPtrOutpu }).(RollingUpdateDaemonSetPatchPtrOutput) } +func (o RollingUpdateDaemonSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDaemonSetPatch] { + return pulumix.Output[RollingUpdateDaemonSetPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update. func (o RollingUpdateDaemonSetPatchOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDaemonSetPatch) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -13591,6 +15482,12 @@ func (o RollingUpdateDaemonSetPatchPtrOutput) ToRollingUpdateDaemonSetPatchPtrOu return o } +func (o RollingUpdateDaemonSetPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDaemonSetPatch] { + return pulumix.Output[*RollingUpdateDaemonSetPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDaemonSetPatchPtrOutput) Elem() RollingUpdateDaemonSetPatchOutput { return o.ApplyT(func(v *RollingUpdateDaemonSetPatch) RollingUpdateDaemonSetPatch { if v != nil { @@ -13650,6 +15547,12 @@ func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentOutput) } +func (i RollingUpdateDeploymentArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentArgs) ToRollingUpdateDeploymentPtrOutput() RollingUpdateDeploymentPtrOutput { return i.ToRollingUpdateDeploymentPtrOutputWithContext(context.Background()) } @@ -13691,6 +15594,12 @@ func (i *rollingUpdateDeploymentPtrType) ToRollingUpdateDeploymentPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPtrOutput) } +func (i *rollingUpdateDeploymentPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: i.ToRollingUpdateDeploymentPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentOutput struct{ *pulumi.OutputState } @@ -13716,6 +15625,12 @@ func (o RollingUpdateDeploymentOutput) ToRollingUpdateDeploymentPtrOutputWithCon }).(RollingUpdateDeploymentPtrOutput) } +func (o RollingUpdateDeploymentOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeployment] { + return pulumix.Output[RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. By default, a value of 1 is used. Example: when this is set to 30%, the new RC can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new RC can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeployment) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -13740,6 +15655,12 @@ func (o RollingUpdateDeploymentPtrOutput) ToRollingUpdateDeploymentPtrOutputWith return o } +func (o RollingUpdateDeploymentPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeployment] { + return pulumix.Output[*RollingUpdateDeployment]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPtrOutput) Elem() RollingUpdateDeploymentOutput { return o.ApplyT(func(v *RollingUpdateDeployment) RollingUpdateDeployment { if v != nil { @@ -13809,6 +15730,12 @@ func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchOutput) } +func (i RollingUpdateDeploymentPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchOutputWithContext(ctx).OutputState, + } +} + func (i RollingUpdateDeploymentPatchArgs) ToRollingUpdateDeploymentPatchPtrOutput() RollingUpdateDeploymentPatchPtrOutput { return i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(context.Background()) } @@ -13850,6 +15777,12 @@ func (i *rollingUpdateDeploymentPatchPtrType) ToRollingUpdateDeploymentPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(RollingUpdateDeploymentPatchPtrOutput) } +func (i *rollingUpdateDeploymentPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: i.ToRollingUpdateDeploymentPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Spec to control the desired behavior of rolling update. type RollingUpdateDeploymentPatchOutput struct{ *pulumi.OutputState } @@ -13875,6 +15808,12 @@ func (o RollingUpdateDeploymentPatchOutput) ToRollingUpdateDeploymentPatchPtrOut }).(RollingUpdateDeploymentPatchPtrOutput) } +func (o RollingUpdateDeploymentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RollingUpdateDeploymentPatch] { + return pulumix.Output[RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + // The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. By default, a value of 1 is used. Example: when this is set to 30%, the new RC can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new RC can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. func (o RollingUpdateDeploymentPatchOutput) MaxSurge() pulumi.AnyOutput { return o.ApplyT(func(v RollingUpdateDeploymentPatch) interface{} { return v.MaxSurge }).(pulumi.AnyOutput) @@ -13899,6 +15838,12 @@ func (o RollingUpdateDeploymentPatchPtrOutput) ToRollingUpdateDeploymentPatchPtr return o } +func (o RollingUpdateDeploymentPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RollingUpdateDeploymentPatch] { + return pulumix.Output[*RollingUpdateDeploymentPatch]{ + OutputState: o.OutputState, + } +} + func (o RollingUpdateDeploymentPatchPtrOutput) Elem() RollingUpdateDeploymentPatchOutput { return o.ApplyT(func(v *RollingUpdateDeploymentPatch) RollingUpdateDeploymentPatch { if v != nil { @@ -13968,6 +15913,12 @@ func (i RunAsGroupStrategyOptionsArgs) ToRunAsGroupStrategyOptionsOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsOutput) } +func (i RunAsGroupStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptions] { + return pulumix.Output[RunAsGroupStrategyOptions]{ + OutputState: i.ToRunAsGroupStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i RunAsGroupStrategyOptionsArgs) ToRunAsGroupStrategyOptionsPtrOutput() RunAsGroupStrategyOptionsPtrOutput { return i.ToRunAsGroupStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -14009,6 +15960,12 @@ func (i *runAsGroupStrategyOptionsPtrType) ToRunAsGroupStrategyOptionsPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsPtrOutput) } +func (i *runAsGroupStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptions] { + return pulumix.Output[*RunAsGroupStrategyOptions]{ + OutputState: i.ToRunAsGroupStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsGroupStrategyOptions from policy API Group instead. type RunAsGroupStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -14034,6 +15991,12 @@ func (o RunAsGroupStrategyOptionsOutput) ToRunAsGroupStrategyOptionsPtrOutputWit }).(RunAsGroupStrategyOptionsPtrOutput) } +func (o RunAsGroupStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptions] { + return pulumix.Output[RunAsGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsGroupStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v RunAsGroupStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -14058,6 +16021,12 @@ func (o RunAsGroupStrategyOptionsPtrOutput) ToRunAsGroupStrategyOptionsPtrOutput return o } +func (o RunAsGroupStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptions] { + return pulumix.Output[*RunAsGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o RunAsGroupStrategyOptionsPtrOutput) Elem() RunAsGroupStrategyOptionsOutput { return o.ApplyT(func(v *RunAsGroupStrategyOptions) RunAsGroupStrategyOptions { if v != nil { @@ -14127,6 +16096,12 @@ func (i RunAsGroupStrategyOptionsPatchArgs) ToRunAsGroupStrategyOptionsPatchOutp return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsPatchOutput) } +func (i RunAsGroupStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[RunAsGroupStrategyOptionsPatch]{ + OutputState: i.ToRunAsGroupStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i RunAsGroupStrategyOptionsPatchArgs) ToRunAsGroupStrategyOptionsPatchPtrOutput() RunAsGroupStrategyOptionsPatchPtrOutput { return i.ToRunAsGroupStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -14168,6 +16143,12 @@ func (i *runAsGroupStrategyOptionsPatchPtrType) ToRunAsGroupStrategyOptionsPatch return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsPatchPtrOutput) } +func (i *runAsGroupStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[*RunAsGroupStrategyOptionsPatch]{ + OutputState: i.ToRunAsGroupStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsGroupStrategyOptions from policy API Group instead. type RunAsGroupStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -14193,6 +16174,12 @@ func (o RunAsGroupStrategyOptionsPatchOutput) ToRunAsGroupStrategyOptionsPatchPt }).(RunAsGroupStrategyOptionsPatchPtrOutput) } +func (o RunAsGroupStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[RunAsGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsGroupStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v RunAsGroupStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -14217,6 +16204,12 @@ func (o RunAsGroupStrategyOptionsPatchPtrOutput) ToRunAsGroupStrategyOptionsPatc return o } +func (o RunAsGroupStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[*RunAsGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o RunAsGroupStrategyOptionsPatchPtrOutput) Elem() RunAsGroupStrategyOptionsPatchOutput { return o.ApplyT(func(v *RunAsGroupStrategyOptionsPatch) RunAsGroupStrategyOptionsPatch { if v != nil { @@ -14286,6 +16279,12 @@ func (i RunAsUserStrategyOptionsArgs) ToRunAsUserStrategyOptionsOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsOutput) } +func (i RunAsUserStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptions] { + return pulumix.Output[RunAsUserStrategyOptions]{ + OutputState: i.ToRunAsUserStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i RunAsUserStrategyOptionsArgs) ToRunAsUserStrategyOptionsPtrOutput() RunAsUserStrategyOptionsPtrOutput { return i.ToRunAsUserStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -14327,6 +16326,12 @@ func (i *runAsUserStrategyOptionsPtrType) ToRunAsUserStrategyOptionsPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsPtrOutput) } +func (i *runAsUserStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptions] { + return pulumix.Output[*RunAsUserStrategyOptions]{ + OutputState: i.ToRunAsUserStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsUserStrategyOptions from policy API Group instead. type RunAsUserStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -14352,6 +16357,12 @@ func (o RunAsUserStrategyOptionsOutput) ToRunAsUserStrategyOptionsPtrOutputWithC }).(RunAsUserStrategyOptionsPtrOutput) } +func (o RunAsUserStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptions] { + return pulumix.Output[RunAsUserStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsUserStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v RunAsUserStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -14376,6 +16387,12 @@ func (o RunAsUserStrategyOptionsPtrOutput) ToRunAsUserStrategyOptionsPtrOutputWi return o } +func (o RunAsUserStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptions] { + return pulumix.Output[*RunAsUserStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o RunAsUserStrategyOptionsPtrOutput) Elem() RunAsUserStrategyOptionsOutput { return o.ApplyT(func(v *RunAsUserStrategyOptions) RunAsUserStrategyOptions { if v != nil { @@ -14445,6 +16462,12 @@ func (i RunAsUserStrategyOptionsPatchArgs) ToRunAsUserStrategyOptionsPatchOutput return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsPatchOutput) } +func (i RunAsUserStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptionsPatch] { + return pulumix.Output[RunAsUserStrategyOptionsPatch]{ + OutputState: i.ToRunAsUserStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i RunAsUserStrategyOptionsPatchArgs) ToRunAsUserStrategyOptionsPatchPtrOutput() RunAsUserStrategyOptionsPatchPtrOutput { return i.ToRunAsUserStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -14486,6 +16509,12 @@ func (i *runAsUserStrategyOptionsPatchPtrType) ToRunAsUserStrategyOptionsPatchPt return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsPatchPtrOutput) } +func (i *runAsUserStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptionsPatch] { + return pulumix.Output[*RunAsUserStrategyOptionsPatch]{ + OutputState: i.ToRunAsUserStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsUserStrategyOptions from policy API Group instead. type RunAsUserStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -14511,6 +16540,12 @@ func (o RunAsUserStrategyOptionsPatchOutput) ToRunAsUserStrategyOptionsPatchPtrO }).(RunAsUserStrategyOptionsPatchPtrOutput) } +func (o RunAsUserStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptionsPatch] { + return pulumix.Output[RunAsUserStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsUserStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v RunAsUserStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -14535,6 +16570,12 @@ func (o RunAsUserStrategyOptionsPatchPtrOutput) ToRunAsUserStrategyOptionsPatchP return o } +func (o RunAsUserStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptionsPatch] { + return pulumix.Output[*RunAsUserStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o RunAsUserStrategyOptionsPatchPtrOutput) Elem() RunAsUserStrategyOptionsPatchOutput { return o.ApplyT(func(v *RunAsUserStrategyOptionsPatch) RunAsUserStrategyOptionsPatch { if v != nil { @@ -14604,6 +16645,12 @@ func (i RuntimeClassStrategyOptionsArgs) ToRuntimeClassStrategyOptionsOutputWith return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsOutput) } +func (i RuntimeClassStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptions] { + return pulumix.Output[RuntimeClassStrategyOptions]{ + OutputState: i.ToRuntimeClassStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i RuntimeClassStrategyOptionsArgs) ToRuntimeClassStrategyOptionsPtrOutput() RuntimeClassStrategyOptionsPtrOutput { return i.ToRuntimeClassStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -14645,6 +16692,12 @@ func (i *runtimeClassStrategyOptionsPtrType) ToRuntimeClassStrategyOptionsPtrOut return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsPtrOutput) } +func (i *runtimeClassStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptions] { + return pulumix.Output[*RuntimeClassStrategyOptions]{ + OutputState: i.ToRuntimeClassStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod. type RuntimeClassStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -14670,6 +16723,12 @@ func (o RuntimeClassStrategyOptionsOutput) ToRuntimeClassStrategyOptionsPtrOutpu }).(RuntimeClassStrategyOptionsPtrOutput) } +func (o RuntimeClassStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptions] { + return pulumix.Output[RuntimeClassStrategyOptions]{ + OutputState: o.OutputState, + } +} + // allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. func (o RuntimeClassStrategyOptionsOutput) AllowedRuntimeClassNames() pulumi.StringArrayOutput { return o.ApplyT(func(v RuntimeClassStrategyOptions) []string { return v.AllowedRuntimeClassNames }).(pulumi.StringArrayOutput) @@ -14694,6 +16753,12 @@ func (o RuntimeClassStrategyOptionsPtrOutput) ToRuntimeClassStrategyOptionsPtrOu return o } +func (o RuntimeClassStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptions] { + return pulumix.Output[*RuntimeClassStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassStrategyOptionsPtrOutput) Elem() RuntimeClassStrategyOptionsOutput { return o.ApplyT(func(v *RuntimeClassStrategyOptions) RuntimeClassStrategyOptions { if v != nil { @@ -14763,6 +16828,12 @@ func (i RuntimeClassStrategyOptionsPatchArgs) ToRuntimeClassStrategyOptionsPatch return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsPatchOutput) } +func (i RuntimeClassStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[RuntimeClassStrategyOptionsPatch]{ + OutputState: i.ToRuntimeClassStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i RuntimeClassStrategyOptionsPatchArgs) ToRuntimeClassStrategyOptionsPatchPtrOutput() RuntimeClassStrategyOptionsPatchPtrOutput { return i.ToRuntimeClassStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -14804,6 +16875,12 @@ func (i *runtimeClassStrategyOptionsPatchPtrType) ToRuntimeClassStrategyOptionsP return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsPatchPtrOutput) } +func (i *runtimeClassStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[*RuntimeClassStrategyOptionsPatch]{ + OutputState: i.ToRuntimeClassStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod. type RuntimeClassStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -14829,6 +16906,12 @@ func (o RuntimeClassStrategyOptionsPatchOutput) ToRuntimeClassStrategyOptionsPat }).(RuntimeClassStrategyOptionsPatchPtrOutput) } +func (o RuntimeClassStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[RuntimeClassStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. func (o RuntimeClassStrategyOptionsPatchOutput) AllowedRuntimeClassNames() pulumi.StringArrayOutput { return o.ApplyT(func(v RuntimeClassStrategyOptionsPatch) []string { return v.AllowedRuntimeClassNames }).(pulumi.StringArrayOutput) @@ -14853,6 +16936,12 @@ func (o RuntimeClassStrategyOptionsPatchPtrOutput) ToRuntimeClassStrategyOptions return o } +func (o RuntimeClassStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[*RuntimeClassStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassStrategyOptionsPatchPtrOutput) Elem() RuntimeClassStrategyOptionsPatchOutput { return o.ApplyT(func(v *RuntimeClassStrategyOptionsPatch) RuntimeClassStrategyOptionsPatch { if v != nil { @@ -14922,6 +17011,12 @@ func (i SELinuxStrategyOptionsArgs) ToSELinuxStrategyOptionsOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsOutput) } +func (i SELinuxStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptions] { + return pulumix.Output[SELinuxStrategyOptions]{ + OutputState: i.ToSELinuxStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i SELinuxStrategyOptionsArgs) ToSELinuxStrategyOptionsPtrOutput() SELinuxStrategyOptionsPtrOutput { return i.ToSELinuxStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -14963,6 +17058,12 @@ func (i *selinuxStrategyOptionsPtrType) ToSELinuxStrategyOptionsPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsPtrOutput) } +func (i *selinuxStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptions] { + return pulumix.Output[*SELinuxStrategyOptions]{ + OutputState: i.ToSELinuxStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use SELinuxStrategyOptions from policy API Group instead. type SELinuxStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -14988,6 +17089,12 @@ func (o SELinuxStrategyOptionsOutput) ToSELinuxStrategyOptionsPtrOutputWithConte }).(SELinuxStrategyOptionsPtrOutput) } +func (o SELinuxStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptions] { + return pulumix.Output[SELinuxStrategyOptions]{ + OutputState: o.OutputState, + } +} + // rule is the strategy that will dictate the allowable labels that may be set. func (o SELinuxStrategyOptionsOutput) Rule() pulumi.StringOutput { return o.ApplyT(func(v SELinuxStrategyOptions) string { return v.Rule }).(pulumi.StringOutput) @@ -15012,6 +17119,12 @@ func (o SELinuxStrategyOptionsPtrOutput) ToSELinuxStrategyOptionsPtrOutputWithCo return o } +func (o SELinuxStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptions] { + return pulumix.Output[*SELinuxStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o SELinuxStrategyOptionsPtrOutput) Elem() SELinuxStrategyOptionsOutput { return o.ApplyT(func(v *SELinuxStrategyOptions) SELinuxStrategyOptions { if v != nil { @@ -15081,6 +17194,12 @@ func (i SELinuxStrategyOptionsPatchArgs) ToSELinuxStrategyOptionsPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsPatchOutput) } +func (i SELinuxStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptionsPatch] { + return pulumix.Output[SELinuxStrategyOptionsPatch]{ + OutputState: i.ToSELinuxStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i SELinuxStrategyOptionsPatchArgs) ToSELinuxStrategyOptionsPatchPtrOutput() SELinuxStrategyOptionsPatchPtrOutput { return i.ToSELinuxStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -15122,6 +17241,12 @@ func (i *selinuxStrategyOptionsPatchPtrType) ToSELinuxStrategyOptionsPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsPatchPtrOutput) } +func (i *selinuxStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptionsPatch] { + return pulumix.Output[*SELinuxStrategyOptionsPatch]{ + OutputState: i.ToSELinuxStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use SELinuxStrategyOptions from policy API Group instead. type SELinuxStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -15147,6 +17272,12 @@ func (o SELinuxStrategyOptionsPatchOutput) ToSELinuxStrategyOptionsPatchPtrOutpu }).(SELinuxStrategyOptionsPatchPtrOutput) } +func (o SELinuxStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptionsPatch] { + return pulumix.Output[SELinuxStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // rule is the strategy that will dictate the allowable labels that may be set. func (o SELinuxStrategyOptionsPatchOutput) Rule() pulumi.StringPtrOutput { return o.ApplyT(func(v SELinuxStrategyOptionsPatch) *string { return v.Rule }).(pulumi.StringPtrOutput) @@ -15171,6 +17302,12 @@ func (o SELinuxStrategyOptionsPatchPtrOutput) ToSELinuxStrategyOptionsPatchPtrOu return o } +func (o SELinuxStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptionsPatch] { + return pulumix.Output[*SELinuxStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o SELinuxStrategyOptionsPatchPtrOutput) Elem() SELinuxStrategyOptionsPatchOutput { return o.ApplyT(func(v *SELinuxStrategyOptionsPatch) SELinuxStrategyOptionsPatch { if v != nil { @@ -15252,6 +17389,12 @@ func (i ScaleArgs) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return pulumi.ToOutputWithContext(ctx, i).(ScaleOutput) } +func (i ScaleArgs) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: i.ToScaleOutputWithContext(ctx).OutputState, + } +} + // represents a scaling request for a resource. type ScaleOutput struct{ *pulumi.OutputState } @@ -15267,6 +17410,12 @@ func (o ScaleOutput) ToScaleOutputWithContext(ctx context.Context) ScaleOutput { return o } +func (o ScaleOutput) ToOutput(ctx context.Context) pulumix.Output[Scale] { + return pulumix.Output[Scale]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScaleOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Scale) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -15343,6 +17492,12 @@ func (i ScalePatchArgs) ToScalePatchOutputWithContext(ctx context.Context) Scale return pulumi.ToOutputWithContext(ctx, i).(ScalePatchOutput) } +func (i ScalePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: i.ToScalePatchOutputWithContext(ctx).OutputState, + } +} + // represents a scaling request for a resource. type ScalePatchOutput struct{ *pulumi.OutputState } @@ -15358,6 +17513,12 @@ func (o ScalePatchOutput) ToScalePatchOutputWithContext(ctx context.Context) Sca return o } +func (o ScalePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScalePatch] { + return pulumix.Output[ScalePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ScalePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ScalePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -15418,6 +17579,12 @@ func (i ScaleSpecArgs) ToScaleSpecOutputWithContext(ctx context.Context) ScaleSp return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecOutput) } +func (i ScaleSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: i.ToScaleSpecOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecArgs) ToScaleSpecPtrOutput() ScaleSpecPtrOutput { return i.ToScaleSpecPtrOutputWithContext(context.Background()) } @@ -15459,6 +17626,12 @@ func (i *scaleSpecPtrType) ToScaleSpecPtrOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPtrOutput) } +func (i *scaleSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: i.ToScaleSpecPtrOutputWithContext(ctx).OutputState, + } +} + // describes the attributes of a scale subresource type ScaleSpecOutput struct{ *pulumi.OutputState } @@ -15484,6 +17657,12 @@ func (o ScaleSpecOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) Sc }).(ScaleSpecPtrOutput) } +func (o ScaleSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpec] { + return pulumix.Output[ScaleSpec]{ + OutputState: o.OutputState, + } +} + // desired number of instances for the scaled object. func (o ScaleSpecOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpec) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -15503,6 +17682,12 @@ func (o ScaleSpecPtrOutput) ToScaleSpecPtrOutputWithContext(ctx context.Context) return o } +func (o ScaleSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpec] { + return pulumix.Output[*ScaleSpec]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPtrOutput) Elem() ScaleSpecOutput { return o.ApplyT(func(v *ScaleSpec) ScaleSpec { if v != nil { @@ -15558,6 +17743,12 @@ func (i ScaleSpecPatchArgs) ToScaleSpecPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchOutput) } +func (i ScaleSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleSpecPatchArgs) ToScaleSpecPatchPtrOutput() ScaleSpecPatchPtrOutput { return i.ToScaleSpecPatchPtrOutputWithContext(context.Background()) } @@ -15599,6 +17790,12 @@ func (i *scaleSpecPatchPtrType) ToScaleSpecPatchPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(ScaleSpecPatchPtrOutput) } +func (i *scaleSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: i.ToScaleSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // describes the attributes of a scale subresource type ScaleSpecPatchOutput struct{ *pulumi.OutputState } @@ -15624,6 +17821,12 @@ func (o ScaleSpecPatchOutput) ToScaleSpecPatchPtrOutputWithContext(ctx context.C }).(ScaleSpecPatchPtrOutput) } +func (o ScaleSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleSpecPatch] { + return pulumix.Output[ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + // desired number of instances for the scaled object. func (o ScaleSpecPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleSpecPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -15643,6 +17846,12 @@ func (o ScaleSpecPatchPtrOutput) ToScaleSpecPatchPtrOutputWithContext(ctx contex return o } +func (o ScaleSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleSpecPatch] { + return pulumix.Output[*ScaleSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleSpecPatchPtrOutput) Elem() ScaleSpecPatchOutput { return o.ApplyT(func(v *ScaleSpecPatch) ScaleSpecPatch { if v != nil { @@ -15706,6 +17915,12 @@ func (i ScaleStatusArgs) ToScaleStatusOutputWithContext(ctx context.Context) Sca return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusOutput) } +func (i ScaleStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: i.ToScaleStatusOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusArgs) ToScaleStatusPtrOutput() ScaleStatusPtrOutput { return i.ToScaleStatusPtrOutputWithContext(context.Background()) } @@ -15747,6 +17962,12 @@ func (i *scaleStatusPtrType) ToScaleStatusPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPtrOutput) } +func (i *scaleStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: i.ToScaleStatusPtrOutputWithContext(ctx).OutputState, + } +} + // represents the current status of a scale subresource. type ScaleStatusOutput struct{ *pulumi.OutputState } @@ -15772,6 +17993,12 @@ func (o ScaleStatusOutput) ToScaleStatusPtrOutputWithContext(ctx context.Context }).(ScaleStatusPtrOutput) } +func (o ScaleStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatus] { + return pulumix.Output[ScaleStatus]{ + OutputState: o.OutputState, + } +} + // actual number of observed instances of the scaled object. func (o ScaleStatusOutput) Replicas() pulumi.IntOutput { return o.ApplyT(func(v ScaleStatus) int { return v.Replicas }).(pulumi.IntOutput) @@ -15801,6 +18028,12 @@ func (o ScaleStatusPtrOutput) ToScaleStatusPtrOutputWithContext(ctx context.Cont return o } +func (o ScaleStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatus] { + return pulumix.Output[*ScaleStatus]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPtrOutput) Elem() ScaleStatusOutput { return o.ApplyT(func(v *ScaleStatus) ScaleStatus { if v != nil { @@ -15884,6 +18117,12 @@ func (i ScaleStatusPatchArgs) ToScaleStatusPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchOutput) } +func (i ScaleStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ScaleStatusPatchArgs) ToScaleStatusPatchPtrOutput() ScaleStatusPatchPtrOutput { return i.ToScaleStatusPatchPtrOutputWithContext(context.Background()) } @@ -15925,6 +18164,12 @@ func (i *scaleStatusPatchPtrType) ToScaleStatusPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ScaleStatusPatchPtrOutput) } +func (i *scaleStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: i.ToScaleStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // represents the current status of a scale subresource. type ScaleStatusPatchOutput struct{ *pulumi.OutputState } @@ -15950,6 +18195,12 @@ func (o ScaleStatusPatchOutput) ToScaleStatusPatchPtrOutputWithContext(ctx conte }).(ScaleStatusPatchPtrOutput) } +func (o ScaleStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ScaleStatusPatch] { + return pulumix.Output[ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + // actual number of observed instances of the scaled object. func (o ScaleStatusPatchOutput) Replicas() pulumi.IntPtrOutput { return o.ApplyT(func(v ScaleStatusPatch) *int { return v.Replicas }).(pulumi.IntPtrOutput) @@ -15979,6 +18230,12 @@ func (o ScaleStatusPatchPtrOutput) ToScaleStatusPatchPtrOutputWithContext(ctx co return o } +func (o ScaleStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ScaleStatusPatch] { + return pulumix.Output[*ScaleStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ScaleStatusPatchPtrOutput) Elem() ScaleStatusPatchOutput { return o.ApplyT(func(v *ScaleStatusPatch) ScaleStatusPatch { if v != nil { @@ -16058,6 +18315,12 @@ func (i SupplementalGroupsStrategyOptionsArgs) ToSupplementalGroupsStrategyOptio return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsOutput) } +func (i SupplementalGroupsStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptions] { + return pulumix.Output[SupplementalGroupsStrategyOptions]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i SupplementalGroupsStrategyOptionsArgs) ToSupplementalGroupsStrategyOptionsPtrOutput() SupplementalGroupsStrategyOptionsPtrOutput { return i.ToSupplementalGroupsStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -16099,6 +18362,12 @@ func (i *supplementalGroupsStrategyOptionsPtrType) ToSupplementalGroupsStrategyO return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsPtrOutput) } +func (i *supplementalGroupsStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptions] { + return pulumix.Output[*SupplementalGroupsStrategyOptions]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use SupplementalGroupsStrategyOptions from policy API Group instead. type SupplementalGroupsStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -16124,6 +18393,12 @@ func (o SupplementalGroupsStrategyOptionsOutput) ToSupplementalGroupsStrategyOpt }).(SupplementalGroupsStrategyOptionsPtrOutput) } +func (o SupplementalGroupsStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptions] { + return pulumix.Output[SupplementalGroupsStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. func (o SupplementalGroupsStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v SupplementalGroupsStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -16148,6 +18423,12 @@ func (o SupplementalGroupsStrategyOptionsPtrOutput) ToSupplementalGroupsStrategy return o } +func (o SupplementalGroupsStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptions] { + return pulumix.Output[*SupplementalGroupsStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o SupplementalGroupsStrategyOptionsPtrOutput) Elem() SupplementalGroupsStrategyOptionsOutput { return o.ApplyT(func(v *SupplementalGroupsStrategyOptions) SupplementalGroupsStrategyOptions { if v != nil { @@ -16217,6 +18498,12 @@ func (i SupplementalGroupsStrategyOptionsPatchArgs) ToSupplementalGroupsStrategy return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsPatchOutput) } +func (i SupplementalGroupsStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[SupplementalGroupsStrategyOptionsPatch]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i SupplementalGroupsStrategyOptionsPatchArgs) ToSupplementalGroupsStrategyOptionsPatchPtrOutput() SupplementalGroupsStrategyOptionsPatchPtrOutput { return i.ToSupplementalGroupsStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -16258,6 +18545,12 @@ func (i *supplementalGroupsStrategyOptionsPatchPtrType) ToSupplementalGroupsStra return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsPatchPtrOutput) } +func (i *supplementalGroupsStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[*SupplementalGroupsStrategyOptionsPatch]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use SupplementalGroupsStrategyOptions from policy API Group instead. type SupplementalGroupsStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -16283,6 +18576,12 @@ func (o SupplementalGroupsStrategyOptionsPatchOutput) ToSupplementalGroupsStrate }).(SupplementalGroupsStrategyOptionsPatchPtrOutput) } +func (o SupplementalGroupsStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[SupplementalGroupsStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. func (o SupplementalGroupsStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v SupplementalGroupsStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -16307,6 +18606,12 @@ func (o SupplementalGroupsStrategyOptionsPatchPtrOutput) ToSupplementalGroupsStr return o } +func (o SupplementalGroupsStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[*SupplementalGroupsStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o SupplementalGroupsStrategyOptionsPatchPtrOutput) Elem() SupplementalGroupsStrategyOptionsPatchOutput { return o.ApplyT(func(v *SupplementalGroupsStrategyOptionsPatch) SupplementalGroupsStrategyOptionsPatch { if v != nil { diff --git a/sdk/go/kubernetes/extensions/v1beta1/replicaSet.go b/sdk/go/kubernetes/extensions/v1beta1/replicaSet.go index 4126e6ec1e..b05a683ef7 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/replicaSet.go +++ b/sdk/go/kubernetes/extensions/v1beta1/replicaSet.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicaSet ensures that a specified number of pod replicas are running at any given time. @@ -126,6 +127,12 @@ func (i *ReplicaSet) ToReplicaSetOutputWithContext(ctx context.Context) ReplicaS return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetOutput) } +func (i *ReplicaSet) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSet] { + return pulumix.Output[*ReplicaSet]{ + OutputState: i.ToReplicaSetOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetArrayInput is an input type that accepts ReplicaSetArray and ReplicaSetArrayOutput values. // You can construct a concrete instance of `ReplicaSetArrayInput` via: // @@ -151,6 +158,12 @@ func (i ReplicaSetArray) ToReplicaSetArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetArrayOutput) } +func (i ReplicaSetArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSet] { + return pulumix.Output[[]*ReplicaSet]{ + OutputState: i.ToReplicaSetArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetMapInput is an input type that accepts ReplicaSetMap and ReplicaSetMapOutput values. // You can construct a concrete instance of `ReplicaSetMapInput` via: // @@ -176,6 +189,12 @@ func (i ReplicaSetMap) ToReplicaSetMapOutputWithContext(ctx context.Context) Rep return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetMapOutput) } +func (i ReplicaSetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSet] { + return pulumix.Output[map[string]*ReplicaSet]{ + OutputState: i.ToReplicaSetMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetOutput struct{ *pulumi.OutputState } func (ReplicaSetOutput) ElementType() reflect.Type { @@ -190,6 +209,12 @@ func (o ReplicaSetOutput) ToReplicaSetOutputWithContext(ctx context.Context) Rep return o } +func (o ReplicaSetOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSet] { + return pulumix.Output[*ReplicaSet]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicaSet) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -229,6 +254,12 @@ func (o ReplicaSetArrayOutput) ToReplicaSetArrayOutputWithContext(ctx context.Co return o } +func (o ReplicaSetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSet] { + return pulumix.Output[[]*ReplicaSet]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetArrayOutput) Index(i pulumi.IntInput) ReplicaSetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSet { return vs[0].([]*ReplicaSet)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o ReplicaSetMapOutput) ToReplicaSetMapOutputWithContext(ctx context.Contex return o } +func (o ReplicaSetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSet] { + return pulumix.Output[map[string]*ReplicaSet]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSet { return vs[0].(map[string]*ReplicaSet)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/replicaSetList.go b/sdk/go/kubernetes/extensions/v1beta1/replicaSetList.go index a36eee5c7c..e3af52a548 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/replicaSetList.go +++ b/sdk/go/kubernetes/extensions/v1beta1/replicaSetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ReplicaSetList is a collection of ReplicaSets. @@ -117,6 +118,12 @@ func (i *ReplicaSetList) ToReplicaSetListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListOutput) } +func (i *ReplicaSetList) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetList] { + return pulumix.Output[*ReplicaSetList]{ + OutputState: i.ToReplicaSetListOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetListArrayInput is an input type that accepts ReplicaSetListArray and ReplicaSetListArrayOutput values. // You can construct a concrete instance of `ReplicaSetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ReplicaSetListArray) ToReplicaSetListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListArrayOutput) } +func (i ReplicaSetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetList] { + return pulumix.Output[[]*ReplicaSetList]{ + OutputState: i.ToReplicaSetListArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetListMapInput is an input type that accepts ReplicaSetListMap and ReplicaSetListMapOutput values. // You can construct a concrete instance of `ReplicaSetListMapInput` via: // @@ -167,6 +180,12 @@ func (i ReplicaSetListMap) ToReplicaSetListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetListMapOutput) } +func (i ReplicaSetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetList] { + return pulumix.Output[map[string]*ReplicaSetList]{ + OutputState: i.ToReplicaSetListMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetListOutput struct{ *pulumi.OutputState } func (ReplicaSetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ReplicaSetListOutput) ToReplicaSetListOutputWithContext(ctx context.Cont return o } +func (o ReplicaSetListOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetList] { + return pulumix.Output[*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ReplicaSetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ReplicaSetListArrayOutput) ToReplicaSetListArrayOutputWithContext(ctx co return o } +func (o ReplicaSetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetList] { + return pulumix.Output[[]*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetListArrayOutput) Index(i pulumi.IntInput) ReplicaSetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSetList { return vs[0].([]*ReplicaSetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ReplicaSetListMapOutput) ToReplicaSetListMapOutputWithContext(ctx contex return o } +func (o ReplicaSetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetList] { + return pulumix.Output[map[string]*ReplicaSetList]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetListMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSetList { return vs[0].(map[string]*ReplicaSetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/extensions/v1beta1/replicaSetPatch.go b/sdk/go/kubernetes/extensions/v1beta1/replicaSetPatch.go index 80db3d6119..1a2026f9f2 100644 --- a/sdk/go/kubernetes/extensions/v1beta1/replicaSetPatch.go +++ b/sdk/go/kubernetes/extensions/v1beta1/replicaSetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *ReplicaSetPatch) ToReplicaSetPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchOutput) } +func (i *ReplicaSetPatch) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetPatch] { + return pulumix.Output[*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetPatchArrayInput is an input type that accepts ReplicaSetPatchArray and ReplicaSetPatchArrayOutput values. // You can construct a concrete instance of `ReplicaSetPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i ReplicaSetPatchArray) ToReplicaSetPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchArrayOutput) } +func (i ReplicaSetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetPatch] { + return pulumix.Output[[]*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ReplicaSetPatchMapInput is an input type that accepts ReplicaSetPatchMap and ReplicaSetPatchMapOutput values. // You can construct a concrete instance of `ReplicaSetPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i ReplicaSetPatchMap) ToReplicaSetPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ReplicaSetPatchMapOutput) } +func (i ReplicaSetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetPatch] { + return pulumix.Output[map[string]*ReplicaSetPatch]{ + OutputState: i.ToReplicaSetPatchMapOutputWithContext(ctx).OutputState, + } +} + type ReplicaSetPatchOutput struct{ *pulumi.OutputState } func (ReplicaSetPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o ReplicaSetPatchOutput) ToReplicaSetPatchOutputWithContext(ctx context.Co return o } +func (o ReplicaSetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ReplicaSetPatch] { + return pulumix.Output[*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ReplicaSetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ReplicaSetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o ReplicaSetPatchArrayOutput) ToReplicaSetPatchArrayOutputWithContext(ctx return o } +func (o ReplicaSetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ReplicaSetPatch] { + return pulumix.Output[[]*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetPatchArrayOutput) Index(i pulumi.IntInput) ReplicaSetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ReplicaSetPatch { return vs[0].([]*ReplicaSetPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o ReplicaSetPatchMapOutput) ToReplicaSetPatchMapOutputWithContext(ctx cont return o } +func (o ReplicaSetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ReplicaSetPatch] { + return pulumix.Output[map[string]*ReplicaSetPatch]{ + OutputState: o.OutputState, + } +} + func (o ReplicaSetPatchMapOutput) MapIndex(k pulumi.StringInput) ReplicaSetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ReplicaSetPatch { return vs[0].(map[string]*ReplicaSetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchema.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchema.go index 9f0f531d57..a9b9518b82 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchema.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchema.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". @@ -127,6 +128,12 @@ func (i *FlowSchema) ToFlowSchemaOutputWithContext(ctx context.Context) FlowSche return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaOutput) } +func (i *FlowSchema) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: i.ToFlowSchemaOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaArrayInput is an input type that accepts FlowSchemaArray and FlowSchemaArrayOutput values. // You can construct a concrete instance of `FlowSchemaArrayInput` via: // @@ -152,6 +159,12 @@ func (i FlowSchemaArray) ToFlowSchemaArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaArrayOutput) } +func (i FlowSchemaArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: i.ToFlowSchemaArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaMapInput is an input type that accepts FlowSchemaMap and FlowSchemaMapOutput values. // You can construct a concrete instance of `FlowSchemaMapInput` via: // @@ -177,6 +190,12 @@ func (i FlowSchemaMap) ToFlowSchemaMapOutputWithContext(ctx context.Context) Flo return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaMapOutput) } +func (i FlowSchemaMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: i.ToFlowSchemaMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaOutput struct{ *pulumi.OutputState } func (FlowSchemaOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o FlowSchemaOutput) ToFlowSchemaOutputWithContext(ctx context.Context) Flo return o } +func (o FlowSchemaOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchema) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o FlowSchemaArrayOutput) ToFlowSchemaArrayOutputWithContext(ctx context.Co return o } +func (o FlowSchemaArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaArrayOutput) Index(i pulumi.IntInput) FlowSchemaOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].([]*FlowSchema)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o FlowSchemaMapOutput) ToFlowSchemaMapOutputWithContext(ctx context.Contex return o } +func (o FlowSchemaMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].(map[string]*FlowSchema)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaList.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaList.go index f20aeffe41..ca6cfb6c39 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaList.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchemaList is a list of FlowSchema objects. @@ -117,6 +118,12 @@ func (i *FlowSchemaList) ToFlowSchemaListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListOutput) } +func (i *FlowSchemaList) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListArrayInput is an input type that accepts FlowSchemaListArray and FlowSchemaListArrayOutput values. // You can construct a concrete instance of `FlowSchemaListArrayInput` via: // @@ -142,6 +149,12 @@ func (i FlowSchemaListArray) ToFlowSchemaListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListArrayOutput) } +func (i FlowSchemaListArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListMapInput is an input type that accepts FlowSchemaListMap and FlowSchemaListMapOutput values. // You can construct a concrete instance of `FlowSchemaListMapInput` via: // @@ -167,6 +180,12 @@ func (i FlowSchemaListMap) ToFlowSchemaListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListMapOutput) } +func (i FlowSchemaListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaListOutput struct{ *pulumi.OutputState } func (FlowSchemaListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o FlowSchemaListOutput) ToFlowSchemaListOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaListOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchemaList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o FlowSchemaListArrayOutput) ToFlowSchemaListArrayOutputWithContext(ctx co return o } +func (o FlowSchemaListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListArrayOutput) Index(i pulumi.IntInput) FlowSchemaListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].([]*FlowSchemaList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o FlowSchemaListMapOutput) ToFlowSchemaListMapOutputWithContext(ctx contex return o } +func (o FlowSchemaListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].(map[string]*FlowSchemaList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaPatch.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaPatch.go index 47c0abf698..f2a109a4f4 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/flowSchemaPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *FlowSchemaPatch) ToFlowSchemaPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchOutput) } +func (i *FlowSchemaPatch) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchArrayInput is an input type that accepts FlowSchemaPatchArray and FlowSchemaPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i FlowSchemaPatchArray) ToFlowSchemaPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchArrayOutput) } +func (i FlowSchemaPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchMapInput is an input type that accepts FlowSchemaPatchMap and FlowSchemaPatchMapOutput values. // You can construct a concrete instance of `FlowSchemaPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i FlowSchemaPatchMap) ToFlowSchemaPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchMapOutput) } +func (i FlowSchemaPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaPatchOutput struct{ *pulumi.OutputState } func (FlowSchemaPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o FlowSchemaPatchOutput) ToFlowSchemaPatchOutputWithContext(ctx context.Co return o } +func (o FlowSchemaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *FlowSchemaPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o FlowSchemaPatchArrayOutput) ToFlowSchemaPatchArrayOutputWithContext(ctx return o } +func (o FlowSchemaPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].([]*FlowSchemaPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o FlowSchemaPatchMapOutput) ToFlowSchemaPatchMapOutputWithContext(ctx cont return o } +func (o FlowSchemaPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].(map[string]*FlowSchemaPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfiguration.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfiguration.go index 9a74dfe129..86786d0990 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfiguration.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfiguration represents the configuration of a priority level. @@ -127,6 +128,12 @@ func (i *PriorityLevelConfiguration) ToPriorityLevelConfigurationOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationOutput) } +func (i *PriorityLevelConfiguration) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationArrayInput is an input type that accepts PriorityLevelConfigurationArray and PriorityLevelConfigurationArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationArrayInput` via: // @@ -152,6 +159,12 @@ func (i PriorityLevelConfigurationArray) ToPriorityLevelConfigurationArrayOutput return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationArrayOutput) } +func (i PriorityLevelConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationMapInput is an input type that accepts PriorityLevelConfigurationMap and PriorityLevelConfigurationMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationMapInput` via: // @@ -177,6 +190,12 @@ func (i PriorityLevelConfigurationMap) ToPriorityLevelConfigurationMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationMapOutput) } +func (i PriorityLevelConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o PriorityLevelConfigurationOutput) ToPriorityLevelConfigurationOutputWith return o } +func (o PriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o PriorityLevelConfigurationArrayOutput) ToPriorityLevelConfigurationArray return o } +func (o PriorityLevelConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].([]*PriorityLevelConfiguration)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o PriorityLevelConfigurationMapOutput) ToPriorityLevelConfigurationMapOutp return o } +func (o PriorityLevelConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].(map[string]*PriorityLevelConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationList.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationList.go index 5d603b6ab7..7a7865223f 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationList.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. @@ -117,6 +118,12 @@ func (i *PriorityLevelConfigurationList) ToPriorityLevelConfigurationListOutputW return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListOutput) } +func (i *PriorityLevelConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListArrayInput is an input type that accepts PriorityLevelConfigurationListArray and PriorityLevelConfigurationListArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityLevelConfigurationListArray) ToPriorityLevelConfigurationListArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListArrayOutput) } +func (i PriorityLevelConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListMapInput is an input type that accepts PriorityLevelConfigurationListMap and PriorityLevelConfigurationListMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityLevelConfigurationListMap) ToPriorityLevelConfigurationListMapOu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListMapOutput) } +func (i PriorityLevelConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationListOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityLevelConfigurationListOutput) ToPriorityLevelConfigurationListOu return o } +func (o PriorityLevelConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityLevelConfigurationListArrayOutput) ToPriorityLevelConfigurationL return o } +func (o PriorityLevelConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].([]*PriorityLevelConfigurationList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityLevelConfigurationListMapOutput) ToPriorityLevelConfigurationLis return o } +func (o PriorityLevelConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].(map[string]*PriorityLevelConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationPatch.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationPatch.go index 46fa146f19..bca395cd59 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/priorityLevelConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *PriorityLevelConfigurationPatch) ToPriorityLevelConfigurationPatchOutpu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchOutput) } +func (i *PriorityLevelConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchArrayInput is an input type that accepts PriorityLevelConfigurationPatchArray and PriorityLevelConfigurationPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i PriorityLevelConfigurationPatchArray) ToPriorityLevelConfigurationPatchA return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchArrayOutput) } +func (i PriorityLevelConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchMapInput is an input type that accepts PriorityLevelConfigurationPatchMap and PriorityLevelConfigurationPatchMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i PriorityLevelConfigurationPatchMap) ToPriorityLevelConfigurationPatchMap return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchMapOutput) } +func (i PriorityLevelConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationPatchOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o PriorityLevelConfigurationPatchOutput) ToPriorityLevelConfigurationPatch return o } +func (o PriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityLevelConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -238,6 +263,12 @@ func (o PriorityLevelConfigurationPatchArrayOutput) ToPriorityLevelConfiguration return o } +func (o PriorityLevelConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].([]*PriorityLevelConfigurationPatch)[vs[1].(int)] @@ -258,6 +289,12 @@ func (o PriorityLevelConfigurationPatchMapOutput) ToPriorityLevelConfigurationPa return o } +func (o PriorityLevelConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].(map[string]*PriorityLevelConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/flowcontrol/v1alpha1/pulumiTypes.go index 7bc7a87285..750b7fae12 100644 --- a/sdk/go/kubernetes/flowcontrol/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/flowcontrol/v1alpha1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -49,6 +50,12 @@ func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodOutput) } +func (i FlowDistinguisherMethodArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodPtrOutput() FlowDistinguisherMethodPtrOutput { return i.ToFlowDistinguisherMethodPtrOutputWithContext(context.Background()) } @@ -90,6 +97,12 @@ func (i *flowDistinguisherMethodPtrType) ToFlowDistinguisherMethodPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPtrOutput) } +func (i *flowDistinguisherMethodPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodOutput struct{ *pulumi.OutputState } @@ -115,6 +128,12 @@ func (o FlowDistinguisherMethodOutput) ToFlowDistinguisherMethodPtrOutputWithCon }).(FlowDistinguisherMethodPtrOutput) } +func (o FlowDistinguisherMethodOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodOutput) Type() pulumi.StringOutput { return o.ApplyT(func(v FlowDistinguisherMethod) string { return v.Type }).(pulumi.StringOutput) @@ -134,6 +153,12 @@ func (o FlowDistinguisherMethodPtrOutput) ToFlowDistinguisherMethodPtrOutputWith return o } +func (o FlowDistinguisherMethodPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPtrOutput) Elem() FlowDistinguisherMethodOutput { return o.ApplyT(func(v *FlowDistinguisherMethod) FlowDistinguisherMethod { if v != nil { @@ -189,6 +214,12 @@ func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchOutput) } +func (i FlowDistinguisherMethodPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchPtrOutput() FlowDistinguisherMethodPatchPtrOutput { return i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(context.Background()) } @@ -230,6 +261,12 @@ func (i *flowDistinguisherMethodPatchPtrType) ToFlowDistinguisherMethodPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchPtrOutput) } +func (i *flowDistinguisherMethodPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodPatchOutput struct{ *pulumi.OutputState } @@ -255,6 +292,12 @@ func (o FlowDistinguisherMethodPatchOutput) ToFlowDistinguisherMethodPatchPtrOut }).(FlowDistinguisherMethodPatchPtrOutput) } +func (o FlowDistinguisherMethodPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodPatchOutput) Type() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowDistinguisherMethodPatch) *string { return v.Type }).(pulumi.StringPtrOutput) @@ -274,6 +317,12 @@ func (o FlowDistinguisherMethodPatchPtrOutput) ToFlowDistinguisherMethodPatchPtr return o } +func (o FlowDistinguisherMethodPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPatchPtrOutput) Elem() FlowDistinguisherMethodPatchOutput { return o.ApplyT(func(v *FlowDistinguisherMethodPatch) FlowDistinguisherMethodPatch { if v != nil { @@ -345,6 +394,12 @@ func (i FlowSchemaTypeArgs) ToFlowSchemaTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeOutput) } +func (i FlowSchemaTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaTypeArrayInput is an input type that accepts FlowSchemaTypeArray and FlowSchemaTypeArrayOutput values. // You can construct a concrete instance of `FlowSchemaTypeArrayInput` via: // @@ -370,6 +425,12 @@ func (i FlowSchemaTypeArray) ToFlowSchemaTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeArrayOutput) } +func (i FlowSchemaTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaTypeOutput struct{ *pulumi.OutputState } @@ -385,6 +446,12 @@ func (o FlowSchemaTypeOutput) ToFlowSchemaTypeOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -424,6 +491,12 @@ func (o FlowSchemaTypeArrayOutput) ToFlowSchemaTypeArrayOutputWithContext(ctx co return o } +func (o FlowSchemaTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaTypeArrayOutput) Index(i pulumi.IntInput) FlowSchemaTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaType { return vs[0].([]FlowSchemaType)[vs[1].(int)] @@ -481,6 +554,12 @@ func (i FlowSchemaConditionArgs) ToFlowSchemaConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionOutput) } +func (i FlowSchemaConditionArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionArrayInput is an input type that accepts FlowSchemaConditionArray and FlowSchemaConditionArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionArrayInput` via: // @@ -506,6 +585,12 @@ func (i FlowSchemaConditionArray) ToFlowSchemaConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionArrayOutput) } +func (i FlowSchemaConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionOutput struct{ *pulumi.OutputState } @@ -521,6 +606,12 @@ func (o FlowSchemaConditionOutput) ToFlowSchemaConditionOutputWithContext(ctx co return o } +func (o FlowSchemaConditionOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -560,6 +651,12 @@ func (o FlowSchemaConditionArrayOutput) ToFlowSchemaConditionArrayOutputWithCont return o } +func (o FlowSchemaConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaCondition { return vs[0].([]FlowSchemaCondition)[vs[1].(int)] @@ -617,6 +714,12 @@ func (i FlowSchemaConditionPatchArgs) ToFlowSchemaConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchOutput) } +func (i FlowSchemaConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionPatchArrayInput is an input type that accepts FlowSchemaConditionPatchArray and FlowSchemaConditionPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionPatchArrayInput` via: // @@ -642,6 +745,12 @@ func (i FlowSchemaConditionPatchArray) ToFlowSchemaConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchArrayOutput) } +func (i FlowSchemaConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionPatchOutput struct{ *pulumi.OutputState } @@ -657,6 +766,12 @@ func (o FlowSchemaConditionPatchOutput) ToFlowSchemaConditionPatchOutputWithCont return o } +func (o FlowSchemaConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -696,6 +811,12 @@ func (o FlowSchemaConditionPatchArrayOutput) ToFlowSchemaConditionPatchArrayOutp return o } +func (o FlowSchemaConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaConditionPatch { return vs[0].([]FlowSchemaConditionPatch)[vs[1].(int)] @@ -749,6 +870,12 @@ func (i FlowSchemaListTypeArgs) ToFlowSchemaListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListTypeOutput) } +func (i FlowSchemaListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: i.ToFlowSchemaListTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaList is a list of FlowSchema objects. type FlowSchemaListTypeOutput struct{ *pulumi.OutputState } @@ -764,6 +891,12 @@ func (o FlowSchemaListTypeOutput) ToFlowSchemaListTypeOutputWithContext(ctx cont return o } +func (o FlowSchemaListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -835,6 +968,12 @@ func (i FlowSchemaPatchTypeArgs) ToFlowSchemaPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchTypeOutput) } +func (i FlowSchemaPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: i.ToFlowSchemaPatchTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaPatchTypeOutput struct{ *pulumi.OutputState } @@ -850,6 +989,12 @@ func (o FlowSchemaPatchTypeOutput) ToFlowSchemaPatchTypeOutputWithContext(ctx co return o } +func (o FlowSchemaPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -922,6 +1067,12 @@ func (i FlowSchemaSpecArgs) ToFlowSchemaSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecOutput) } +func (i FlowSchemaSpecArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecArgs) ToFlowSchemaSpecPtrOutput() FlowSchemaSpecPtrOutput { return i.ToFlowSchemaSpecPtrOutputWithContext(context.Background()) } @@ -963,6 +1114,12 @@ func (i *flowSchemaSpecPtrType) ToFlowSchemaSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPtrOutput) } +func (i *flowSchemaSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecOutput struct{ *pulumi.OutputState } @@ -988,6 +1145,12 @@ func (o FlowSchemaSpecOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx context.C }).(FlowSchemaSpecPtrOutput) } +func (o FlowSchemaSpecOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecOutput) DistinguisherMethod() FlowDistinguisherMethodPtrOutput { return o.ApplyT(func(v FlowSchemaSpec) *FlowDistinguisherMethod { return v.DistinguisherMethod }).(FlowDistinguisherMethodPtrOutput) @@ -1022,6 +1185,12 @@ func (o FlowSchemaSpecPtrOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx contex return o } +func (o FlowSchemaSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPtrOutput) Elem() FlowSchemaSpecOutput { return o.ApplyT(func(v *FlowSchemaSpec) FlowSchemaSpec { if v != nil { @@ -1119,6 +1288,12 @@ func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchOutput) } +func (i FlowSchemaSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchPtrOutput() FlowSchemaSpecPatchPtrOutput { return i.ToFlowSchemaSpecPatchPtrOutputWithContext(context.Background()) } @@ -1160,6 +1335,12 @@ func (i *flowSchemaSpecPatchPtrType) ToFlowSchemaSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchPtrOutput) } +func (i *flowSchemaSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecPatchOutput struct{ *pulumi.OutputState } @@ -1185,6 +1366,12 @@ func (o FlowSchemaSpecPatchOutput) ToFlowSchemaSpecPatchPtrOutputWithContext(ctx }).(FlowSchemaSpecPatchPtrOutput) } +func (o FlowSchemaSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecPatchOutput) DistinguisherMethod() FlowDistinguisherMethodPatchPtrOutput { return o.ApplyT(func(v FlowSchemaSpecPatch) *FlowDistinguisherMethodPatch { return v.DistinguisherMethod }).(FlowDistinguisherMethodPatchPtrOutput) @@ -1221,6 +1408,12 @@ func (o FlowSchemaSpecPatchPtrOutput) ToFlowSchemaSpecPatchPtrOutputWithContext( return o } +func (o FlowSchemaSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPatchPtrOutput) Elem() FlowSchemaSpecPatchOutput { return o.ApplyT(func(v *FlowSchemaSpecPatch) FlowSchemaSpecPatch { if v != nil { @@ -1306,6 +1499,12 @@ func (i FlowSchemaStatusArgs) ToFlowSchemaStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusOutput) } +func (i FlowSchemaStatusArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusArgs) ToFlowSchemaStatusPtrOutput() FlowSchemaStatusPtrOutput { return i.ToFlowSchemaStatusPtrOutputWithContext(context.Background()) } @@ -1347,6 +1546,12 @@ func (i *flowSchemaStatusPtrType) ToFlowSchemaStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPtrOutput) } +func (i *flowSchemaStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusOutput struct{ *pulumi.OutputState } @@ -1372,6 +1577,12 @@ func (o FlowSchemaStatusOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx conte }).(FlowSchemaStatusPtrOutput) } +func (o FlowSchemaStatusOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusOutput) Conditions() FlowSchemaConditionArrayOutput { return o.ApplyT(func(v FlowSchemaStatus) []FlowSchemaCondition { return v.Conditions }).(FlowSchemaConditionArrayOutput) @@ -1391,6 +1602,12 @@ func (o FlowSchemaStatusPtrOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx co return o } +func (o FlowSchemaStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPtrOutput) Elem() FlowSchemaStatusOutput { return o.ApplyT(func(v *FlowSchemaStatus) FlowSchemaStatus { if v != nil { @@ -1446,6 +1663,12 @@ func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchOutput) } +func (i FlowSchemaStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchPtrOutput() FlowSchemaStatusPatchPtrOutput { return i.ToFlowSchemaStatusPatchPtrOutputWithContext(context.Background()) } @@ -1487,6 +1710,12 @@ func (i *flowSchemaStatusPatchPtrType) ToFlowSchemaStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchPtrOutput) } +func (i *flowSchemaStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusPatchOutput struct{ *pulumi.OutputState } @@ -1512,6 +1741,12 @@ func (o FlowSchemaStatusPatchOutput) ToFlowSchemaStatusPatchPtrOutputWithContext }).(FlowSchemaStatusPatchPtrOutput) } +func (o FlowSchemaStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusPatchOutput) Conditions() FlowSchemaConditionPatchArrayOutput { return o.ApplyT(func(v FlowSchemaStatusPatch) []FlowSchemaConditionPatch { return v.Conditions }).(FlowSchemaConditionPatchArrayOutput) @@ -1531,6 +1766,12 @@ func (o FlowSchemaStatusPatchPtrOutput) ToFlowSchemaStatusPatchPtrOutputWithCont return o } +func (o FlowSchemaStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPatchPtrOutput) Elem() FlowSchemaStatusPatchOutput { return o.ApplyT(func(v *FlowSchemaStatusPatch) FlowSchemaStatusPatch { if v != nil { @@ -1586,6 +1827,12 @@ func (i GroupSubjectArgs) ToGroupSubjectOutputWithContext(ctx context.Context) G return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectOutput) } +func (i GroupSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: i.ToGroupSubjectOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectArgs) ToGroupSubjectPtrOutput() GroupSubjectPtrOutput { return i.ToGroupSubjectPtrOutputWithContext(context.Background()) } @@ -1627,6 +1874,12 @@ func (i *groupSubjectPtrType) ToGroupSubjectPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPtrOutput) } +func (i *groupSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: i.ToGroupSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectOutput struct{ *pulumi.OutputState } @@ -1652,6 +1905,12 @@ func (o GroupSubjectOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Conte }).(GroupSubjectPtrOutput) } +func (o GroupSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v GroupSubject) string { return v.Name }).(pulumi.StringOutput) @@ -1671,6 +1930,12 @@ func (o GroupSubjectPtrOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Co return o } +func (o GroupSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPtrOutput) Elem() GroupSubjectOutput { return o.ApplyT(func(v *GroupSubject) GroupSubject { if v != nil { @@ -1726,6 +1991,12 @@ func (i GroupSubjectPatchArgs) ToGroupSubjectPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchOutput) } +func (i GroupSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectPatchArgs) ToGroupSubjectPatchPtrOutput() GroupSubjectPatchPtrOutput { return i.ToGroupSubjectPatchPtrOutputWithContext(context.Background()) } @@ -1767,6 +2038,12 @@ func (i *groupSubjectPatchPtrType) ToGroupSubjectPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchPtrOutput) } +func (i *groupSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectPatchOutput struct{ *pulumi.OutputState } @@ -1792,6 +2069,12 @@ func (o GroupSubjectPatchOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx con }).(GroupSubjectPatchPtrOutput) } +func (o GroupSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v GroupSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1811,6 +2094,12 @@ func (o GroupSubjectPatchPtrOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx return o } +func (o GroupSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPatchPtrOutput) Elem() GroupSubjectPatchOutput { return o.ApplyT(func(v *GroupSubjectPatch) GroupSubjectPatch { if v != nil { @@ -1870,6 +2159,12 @@ func (i LimitResponseArgs) ToLimitResponseOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LimitResponseOutput) } +func (i LimitResponseArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: i.ToLimitResponseOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponseArgs) ToLimitResponsePtrOutput() LimitResponsePtrOutput { return i.ToLimitResponsePtrOutputWithContext(context.Background()) } @@ -1911,6 +2206,12 @@ func (i *limitResponsePtrType) ToLimitResponsePtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePtrOutput) } +func (i *limitResponsePtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: i.ToLimitResponsePtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponseOutput struct{ *pulumi.OutputState } @@ -1936,6 +2237,12 @@ func (o LimitResponseOutput) ToLimitResponsePtrOutputWithContext(ctx context.Con }).(LimitResponsePtrOutput) } +func (o LimitResponseOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponseOutput) Queuing() QueuingConfigurationPtrOutput { return o.ApplyT(func(v LimitResponse) *QueuingConfiguration { return v.Queuing }).(QueuingConfigurationPtrOutput) @@ -1960,6 +2267,12 @@ func (o LimitResponsePtrOutput) ToLimitResponsePtrOutputWithContext(ctx context. return o } +func (o LimitResponsePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePtrOutput) Elem() LimitResponseOutput { return o.ApplyT(func(v *LimitResponse) LimitResponse { if v != nil { @@ -2029,6 +2342,12 @@ func (i LimitResponsePatchArgs) ToLimitResponsePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchOutput) } +func (i LimitResponsePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponsePatchArgs) ToLimitResponsePatchPtrOutput() LimitResponsePatchPtrOutput { return i.ToLimitResponsePatchPtrOutputWithContext(context.Background()) } @@ -2070,6 +2389,12 @@ func (i *limitResponsePatchPtrType) ToLimitResponsePatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchPtrOutput) } +func (i *limitResponsePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponsePatchOutput struct{ *pulumi.OutputState } @@ -2095,6 +2420,12 @@ func (o LimitResponsePatchOutput) ToLimitResponsePatchPtrOutputWithContext(ctx c }).(LimitResponsePatchPtrOutput) } +func (o LimitResponsePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponsePatchOutput) Queuing() QueuingConfigurationPatchPtrOutput { return o.ApplyT(func(v LimitResponsePatch) *QueuingConfigurationPatch { return v.Queuing }).(QueuingConfigurationPatchPtrOutput) @@ -2119,6 +2450,12 @@ func (o LimitResponsePatchPtrOutput) ToLimitResponsePatchPtrOutputWithContext(ct return o } +func (o LimitResponsePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePatchPtrOutput) Elem() LimitResponsePatchOutput { return o.ApplyT(func(v *LimitResponsePatch) LimitResponsePatch { if v != nil { @@ -2200,6 +2537,12 @@ func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationOutput) } +func (i LimitedPriorityLevelConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurationPtrOutput() LimitedPriorityLevelConfigurationPtrOutput { return i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(context.Background()) } @@ -2241,6 +2584,12 @@ func (i *limitedPriorityLevelConfigurationPtrType) ToLimitedPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPtrOutput) } +func (i *limitedPriorityLevelConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2268,6 +2617,12 @@ func (o LimitedPriorityLevelConfigurationOutput) ToLimitedPriorityLevelConfigura }).(LimitedPriorityLevelConfigurationPtrOutput) } +func (o LimitedPriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: // // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) @@ -2296,6 +2651,12 @@ func (o LimitedPriorityLevelConfigurationPtrOutput) ToLimitedPriorityLevelConfig return o } +func (o LimitedPriorityLevelConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPtrOutput) Elem() LimitedPriorityLevelConfigurationOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfiguration) LimitedPriorityLevelConfiguration { if v != nil { @@ -2381,6 +2742,12 @@ func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfig return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchOutput) } +func (i LimitedPriorityLevelConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfigurationPatchPtrOutput() LimitedPriorityLevelConfigurationPatchPtrOutput { return i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -2422,6 +2789,12 @@ func (i *limitedPriorityLevelConfigurationPatchPtrType) ToLimitedPriorityLevelCo return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (i *limitedPriorityLevelConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2449,6 +2822,12 @@ func (o LimitedPriorityLevelConfigurationPatchOutput) ToLimitedPriorityLevelConf }).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (o LimitedPriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: // // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) @@ -2477,6 +2856,12 @@ func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToLimitedPriorityLevelC return o } +func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPatchPtrOutput) Elem() LimitedPriorityLevelConfigurationPatchOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfigurationPatch) LimitedPriorityLevelConfigurationPatch { if v != nil { @@ -2562,6 +2947,12 @@ func (i NonResourcePolicyRuleArgs) ToNonResourcePolicyRuleOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleOutput) } +func (i NonResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRuleArrayInput is an input type that accepts NonResourcePolicyRuleArray and NonResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRuleArrayInput` via: // @@ -2587,6 +2978,12 @@ func (i NonResourcePolicyRuleArray) ToNonResourcePolicyRuleArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleArrayOutput) } +func (i NonResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -2602,6 +2999,12 @@ func (o NonResourcePolicyRuleOutput) ToNonResourcePolicyRuleOutputWithContext(ct return o } +func (o NonResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -2632,6 +3035,12 @@ func (o NonResourcePolicyRuleArrayOutput) ToNonResourcePolicyRuleArrayOutputWith return o } +func (o NonResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRule { return vs[0].([]NonResourcePolicyRule)[vs[1].(int)] @@ -2689,6 +3098,12 @@ func (i NonResourcePolicyRulePatchArgs) ToNonResourcePolicyRulePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchOutput) } +func (i NonResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRulePatchArrayInput is an input type that accepts NonResourcePolicyRulePatchArray and NonResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRulePatchArrayInput` via: // @@ -2714,6 +3129,12 @@ func (i NonResourcePolicyRulePatchArray) ToNonResourcePolicyRulePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchArrayOutput) } +func (i NonResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -2729,6 +3150,12 @@ func (o NonResourcePolicyRulePatchOutput) ToNonResourcePolicyRulePatchOutputWith return o } +func (o NonResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -2759,6 +3186,12 @@ func (o NonResourcePolicyRulePatchArrayOutput) ToNonResourcePolicyRulePatchArray return o } +func (o NonResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRulePatch { return vs[0].([]NonResourcePolicyRulePatch)[vs[1].(int)] @@ -2808,6 +3241,12 @@ func (i PolicyRulesWithSubjectsArgs) ToPolicyRulesWithSubjectsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsOutput) } +func (i PolicyRulesWithSubjectsArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsArrayInput is an input type that accepts PolicyRulesWithSubjectsArray and PolicyRulesWithSubjectsArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsArrayInput` via: // @@ -2833,6 +3272,12 @@ func (i PolicyRulesWithSubjectsArray) ToPolicyRulesWithSubjectsArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsArrayOutput) } +func (i PolicyRulesWithSubjectsArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsOutput struct{ *pulumi.OutputState } @@ -2848,6 +3293,12 @@ func (o PolicyRulesWithSubjectsOutput) ToPolicyRulesWithSubjectsOutputWithContex return o } +func (o PolicyRulesWithSubjectsOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsOutput) NonResourceRules() NonResourcePolicyRuleArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjects) []NonResourcePolicyRule { return v.NonResourceRules }).(NonResourcePolicyRuleArrayOutput) @@ -2877,6 +3328,12 @@ func (o PolicyRulesWithSubjectsArrayOutput) ToPolicyRulesWithSubjectsArrayOutput return o } +func (o PolicyRulesWithSubjectsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjects { return vs[0].([]PolicyRulesWithSubjects)[vs[1].(int)] @@ -2926,6 +3383,12 @@ func (i PolicyRulesWithSubjectsPatchArgs) ToPolicyRulesWithSubjectsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchOutput) } +func (i PolicyRulesWithSubjectsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsPatchArrayInput is an input type that accepts PolicyRulesWithSubjectsPatchArray and PolicyRulesWithSubjectsPatchArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsPatchArrayInput` via: // @@ -2951,6 +3414,12 @@ func (i PolicyRulesWithSubjectsPatchArray) ToPolicyRulesWithSubjectsPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchArrayOutput) } +func (i PolicyRulesWithSubjectsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsPatchOutput struct{ *pulumi.OutputState } @@ -2966,6 +3435,12 @@ func (o PolicyRulesWithSubjectsPatchOutput) ToPolicyRulesWithSubjectsPatchOutput return o } +func (o PolicyRulesWithSubjectsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsPatchOutput) NonResourceRules() NonResourcePolicyRulePatchArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjectsPatch) []NonResourcePolicyRulePatch { return v.NonResourceRules }).(NonResourcePolicyRulePatchArrayOutput) @@ -2995,6 +3470,12 @@ func (o PolicyRulesWithSubjectsPatchArrayOutput) ToPolicyRulesWithSubjectsPatchA return o } +func (o PolicyRulesWithSubjectsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsPatchArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjectsPatch { return vs[0].([]PolicyRulesWithSubjectsPatch)[vs[1].(int)] @@ -3052,6 +3533,12 @@ func (i PriorityLevelConfigurationTypeArgs) ToPriorityLevelConfigurationTypeOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeOutput) } +func (i PriorityLevelConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationTypeArrayInput is an input type that accepts PriorityLevelConfigurationTypeArray and PriorityLevelConfigurationTypeArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationTypeArrayInput` via: // @@ -3077,6 +3564,12 @@ func (i PriorityLevelConfigurationTypeArray) ToPriorityLevelConfigurationTypeArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeArrayOutput) } +func (i PriorityLevelConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -3092,6 +3585,12 @@ func (o PriorityLevelConfigurationTypeOutput) ToPriorityLevelConfigurationTypeOu return o } +func (o PriorityLevelConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3131,6 +3630,12 @@ func (o PriorityLevelConfigurationTypeArrayOutput) ToPriorityLevelConfigurationT return o } +func (o PriorityLevelConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationTypeArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationType { return vs[0].([]PriorityLevelConfigurationType)[vs[1].(int)] @@ -3188,6 +3693,12 @@ func (i PriorityLevelConfigurationConditionArgs) ToPriorityLevelConfigurationCon return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionOutput) } +func (i PriorityLevelConfigurationConditionArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionArrayInput is an input type that accepts PriorityLevelConfigurationConditionArray and PriorityLevelConfigurationConditionArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionArrayInput` via: // @@ -3213,6 +3724,12 @@ func (i PriorityLevelConfigurationConditionArray) ToPriorityLevelConfigurationCo return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionArrayOutput) } +func (i PriorityLevelConfigurationConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionOutput struct{ *pulumi.OutputState } @@ -3228,6 +3745,12 @@ func (o PriorityLevelConfigurationConditionOutput) ToPriorityLevelConfigurationC return o } +func (o PriorityLevelConfigurationConditionOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3267,6 +3790,12 @@ func (o PriorityLevelConfigurationConditionArrayOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationCondition { return vs[0].([]PriorityLevelConfigurationCondition)[vs[1].(int)] @@ -3324,6 +3853,12 @@ func (i PriorityLevelConfigurationConditionPatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchOutput) } +func (i PriorityLevelConfigurationConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionPatchArrayInput is an input type that accepts PriorityLevelConfigurationConditionPatchArray and PriorityLevelConfigurationConditionPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionPatchArrayInput` via: // @@ -3349,6 +3884,12 @@ func (i PriorityLevelConfigurationConditionPatchArray) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchArrayOutput) } +func (i PriorityLevelConfigurationConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionPatchOutput struct{ *pulumi.OutputState } @@ -3364,6 +3905,12 @@ func (o PriorityLevelConfigurationConditionPatchOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3403,6 +3950,12 @@ func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToPriorityLevelConf return o } +func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationConditionPatch { return vs[0].([]PriorityLevelConfigurationConditionPatch)[vs[1].(int)] @@ -3456,6 +4009,12 @@ func (i PriorityLevelConfigurationListTypeArgs) ToPriorityLevelConfigurationList return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListTypeOutput) } +func (i PriorityLevelConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: i.ToPriorityLevelConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. type PriorityLevelConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -3471,6 +4030,12 @@ func (o PriorityLevelConfigurationListTypeOutput) ToPriorityLevelConfigurationLi return o } +func (o PriorityLevelConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3542,6 +4107,12 @@ func (i PriorityLevelConfigurationPatchTypeArgs) ToPriorityLevelConfigurationPat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchTypeOutput) } +func (i PriorityLevelConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: i.ToPriorityLevelConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -3557,6 +4128,12 @@ func (o PriorityLevelConfigurationPatchTypeOutput) ToPriorityLevelConfigurationP return o } +func (o PriorityLevelConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3617,6 +4194,12 @@ func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationRef return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferenceOutput) } +func (i PriorityLevelConfigurationReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferenceOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationReferencePtrOutput() PriorityLevelConfigurationReferencePtrOutput { return i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(context.Background()) } @@ -3658,6 +4241,12 @@ func (i *priorityLevelConfigurationReferencePtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePtrOutput) } +func (i *priorityLevelConfigurationReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferenceOutput struct{ *pulumi.OutputState } @@ -3683,6 +4272,12 @@ func (o PriorityLevelConfigurationReferenceOutput) ToPriorityLevelConfigurationR }).(PriorityLevelConfigurationReferencePtrOutput) } +func (o PriorityLevelConfigurationReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PriorityLevelConfigurationReference) string { return v.Name }).(pulumi.StringOutput) @@ -3702,6 +4297,12 @@ func (o PriorityLevelConfigurationReferencePtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePtrOutput) Elem() PriorityLevelConfigurationReferenceOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReference) PriorityLevelConfigurationReference { if v != nil { @@ -3757,6 +4358,12 @@ func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchOutput) } +func (i PriorityLevelConfigurationReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurationReferencePatchPtrOutput() PriorityLevelConfigurationReferencePatchPtrOutput { return i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(context.Background()) } @@ -3798,6 +4405,12 @@ func (i *priorityLevelConfigurationReferencePatchPtrType) ToPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (i *priorityLevelConfigurationReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferencePatchOutput struct{ *pulumi.OutputState } @@ -3823,6 +4436,12 @@ func (o PriorityLevelConfigurationReferencePatchOutput) ToPriorityLevelConfigura }).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (o PriorityLevelConfigurationReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -3842,6 +4461,12 @@ func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToPriorityLevelConfig return o } +func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePatchPtrOutput) Elem() PriorityLevelConfigurationReferencePatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReferencePatch) PriorityLevelConfigurationReferencePatch { if v != nil { @@ -3901,6 +4526,12 @@ func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecOutput) } +func (i PriorityLevelConfigurationSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecPtrOutput() PriorityLevelConfigurationSpecPtrOutput { return i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(context.Background()) } @@ -3942,6 +4573,12 @@ func (i *priorityLevelConfigurationSpecPtrType) ToPriorityLevelConfigurationSpec return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPtrOutput) } +func (i *priorityLevelConfigurationSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecOutput struct{ *pulumi.OutputState } @@ -3967,6 +4604,12 @@ func (o PriorityLevelConfigurationSpecOutput) ToPriorityLevelConfigurationSpecPt }).(PriorityLevelConfigurationSpecPtrOutput) } +func (o PriorityLevelConfigurationSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + // `limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `"Limited"`. func (o PriorityLevelConfigurationSpecOutput) Limited() LimitedPriorityLevelConfigurationPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpec) *LimitedPriorityLevelConfiguration { return v.Limited }).(LimitedPriorityLevelConfigurationPtrOutput) @@ -3991,6 +4634,12 @@ func (o PriorityLevelConfigurationSpecPtrOutput) ToPriorityLevelConfigurationSpe return o } +func (o PriorityLevelConfigurationSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPtrOutput) Elem() PriorityLevelConfigurationSpecOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpec) PriorityLevelConfigurationSpec { if v != nil { @@ -4060,6 +4709,12 @@ func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpe return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchOutput) } +func (i PriorityLevelConfigurationSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpecPatchPtrOutput() PriorityLevelConfigurationSpecPatchPtrOutput { return i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(context.Background()) } @@ -4101,6 +4756,12 @@ func (i *priorityLevelConfigurationSpecPatchPtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (i *priorityLevelConfigurationSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecPatchOutput struct{ *pulumi.OutputState } @@ -4126,6 +4787,12 @@ func (o PriorityLevelConfigurationSpecPatchOutput) ToPriorityLevelConfigurationS }).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (o PriorityLevelConfigurationSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + // `limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `"Limited"`. func (o PriorityLevelConfigurationSpecPatchOutput) Limited() LimitedPriorityLevelConfigurationPatchPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpecPatch) *LimitedPriorityLevelConfigurationPatch { return v.Limited }).(LimitedPriorityLevelConfigurationPatchPtrOutput) @@ -4150,6 +4817,12 @@ func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPatchPtrOutput) Elem() PriorityLevelConfigurationSpecPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpecPatch) PriorityLevelConfigurationSpecPatch { if v != nil { @@ -4215,6 +4888,12 @@ func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatus return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusOutput) } +func (i PriorityLevelConfigurationStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatusPtrOutput() PriorityLevelConfigurationStatusPtrOutput { return i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(context.Background()) } @@ -4256,6 +4935,12 @@ func (i *priorityLevelConfigurationStatusPtrType) ToPriorityLevelConfigurationSt return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPtrOutput) } +func (i *priorityLevelConfigurationStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusOutput struct{ *pulumi.OutputState } @@ -4281,6 +4966,12 @@ func (o PriorityLevelConfigurationStatusOutput) ToPriorityLevelConfigurationStat }).(PriorityLevelConfigurationStatusPtrOutput) } +func (o PriorityLevelConfigurationStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusOutput) Conditions() PriorityLevelConfigurationConditionArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatus) []PriorityLevelConfigurationCondition { return v.Conditions }).(PriorityLevelConfigurationConditionArrayOutput) @@ -4300,6 +4991,12 @@ func (o PriorityLevelConfigurationStatusPtrOutput) ToPriorityLevelConfigurationS return o } +func (o PriorityLevelConfigurationStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPtrOutput) Elem() PriorityLevelConfigurationStatusOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatus) PriorityLevelConfigurationStatus { if v != nil { @@ -4355,6 +5052,12 @@ func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationS return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchOutput) } +func (i PriorityLevelConfigurationStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationStatusPatchPtrOutput() PriorityLevelConfigurationStatusPatchPtrOutput { return i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(context.Background()) } @@ -4396,6 +5099,12 @@ func (i *priorityLevelConfigurationStatusPatchPtrType) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (i *priorityLevelConfigurationStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusPatchOutput struct{ *pulumi.OutputState } @@ -4421,6 +5130,12 @@ func (o PriorityLevelConfigurationStatusPatchOutput) ToPriorityLevelConfiguratio }).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (o PriorityLevelConfigurationStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusPatchOutput) Conditions() PriorityLevelConfigurationConditionPatchArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatusPatch) []PriorityLevelConfigurationConditionPatch { @@ -4442,6 +5157,12 @@ func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPatchPtrOutput) Elem() PriorityLevelConfigurationStatusPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatusPatch) PriorityLevelConfigurationStatusPatch { if v != nil { @@ -4505,6 +5226,12 @@ func (i QueuingConfigurationArgs) ToQueuingConfigurationOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationOutput) } +func (i QueuingConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationArgs) ToQueuingConfigurationPtrOutput() QueuingConfigurationPtrOutput { return i.ToQueuingConfigurationPtrOutputWithContext(context.Background()) } @@ -4546,6 +5273,12 @@ func (i *queuingConfigurationPtrType) ToQueuingConfigurationPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPtrOutput) } +func (i *queuingConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationOutput struct{ *pulumi.OutputState } @@ -4571,6 +5304,12 @@ func (o QueuingConfigurationOutput) ToQueuingConfigurationPtrOutputWithContext(c }).(QueuingConfigurationPtrOutput) } +func (o QueuingConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfiguration) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -4600,6 +5339,12 @@ func (o QueuingConfigurationPtrOutput) ToQueuingConfigurationPtrOutputWithContex return o } +func (o QueuingConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPtrOutput) Elem() QueuingConfigurationOutput { return o.ApplyT(func(v *QueuingConfiguration) QueuingConfiguration { if v != nil { @@ -4683,6 +5428,12 @@ func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchOutput) } +func (i QueuingConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchPtrOutput() QueuingConfigurationPatchPtrOutput { return i.ToQueuingConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -4724,6 +5475,12 @@ func (i *queuingConfigurationPatchPtrType) ToQueuingConfigurationPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchPtrOutput) } +func (i *queuingConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationPatchOutput struct{ *pulumi.OutputState } @@ -4749,6 +5506,12 @@ func (o QueuingConfigurationPatchOutput) ToQueuingConfigurationPatchPtrOutputWit }).(QueuingConfigurationPatchPtrOutput) } +func (o QueuingConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationPatchOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfigurationPatch) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -4778,6 +5541,12 @@ func (o QueuingConfigurationPatchPtrOutput) ToQueuingConfigurationPatchPtrOutput return o } +func (o QueuingConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPatchPtrOutput) Elem() QueuingConfigurationPatchOutput { return o.ApplyT(func(v *QueuingConfigurationPatch) QueuingConfigurationPatch { if v != nil { @@ -4869,6 +5638,12 @@ func (i ResourcePolicyRuleArgs) ToResourcePolicyRuleOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleOutput) } +func (i ResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRuleArrayInput is an input type that accepts ResourcePolicyRuleArray and ResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRuleArrayInput` via: // @@ -4894,6 +5669,12 @@ func (i ResourcePolicyRuleArray) ToResourcePolicyRuleArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleArrayOutput) } +func (i ResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request. type ResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -4909,6 +5690,12 @@ func (o ResourcePolicyRuleOutput) ToResourcePolicyRuleOutputWithContext(ctx cont return o } +func (o ResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -4948,6 +5735,12 @@ func (o ResourcePolicyRuleArrayOutput) ToResourcePolicyRuleArrayOutputWithContex return o } +func (o ResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRule { return vs[0].([]ResourcePolicyRule)[vs[1].(int)] @@ -5005,6 +5798,12 @@ func (i ResourcePolicyRulePatchArgs) ToResourcePolicyRulePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchOutput) } +func (i ResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRulePatchArrayInput is an input type that accepts ResourcePolicyRulePatchArray and ResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRulePatchArrayInput` via: // @@ -5030,6 +5829,12 @@ func (i ResourcePolicyRulePatchArray) ToResourcePolicyRulePatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchArrayOutput) } +func (i ResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request. type ResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -5045,6 +5850,12 @@ func (o ResourcePolicyRulePatchOutput) ToResourcePolicyRulePatchOutputWithContex return o } +func (o ResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -5084,6 +5895,12 @@ func (o ResourcePolicyRulePatchArrayOutput) ToResourcePolicyRulePatchArrayOutput return o } +func (o ResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRulePatch { return vs[0].([]ResourcePolicyRulePatch)[vs[1].(int)] @@ -5129,6 +5946,12 @@ func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectOutput) } +func (i ServiceAccountSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectPtrOutput() ServiceAccountSubjectPtrOutput { return i.ToServiceAccountSubjectPtrOutputWithContext(context.Background()) } @@ -5170,6 +5993,12 @@ func (i *serviceAccountSubjectPtrType) ToServiceAccountSubjectPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPtrOutput) } +func (i *serviceAccountSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectOutput struct{ *pulumi.OutputState } @@ -5195,6 +6024,12 @@ func (o ServiceAccountSubjectOutput) ToServiceAccountSubjectPtrOutputWithContext }).(ServiceAccountSubjectPtrOutput) } +func (o ServiceAccountSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceAccountSubject) string { return v.Name }).(pulumi.StringOutput) @@ -5219,6 +6054,12 @@ func (o ServiceAccountSubjectPtrOutput) ToServiceAccountSubjectPtrOutputWithCont return o } +func (o ServiceAccountSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPtrOutput) Elem() ServiceAccountSubjectOutput { return o.ApplyT(func(v *ServiceAccountSubject) ServiceAccountSubject { if v != nil { @@ -5288,6 +6129,12 @@ func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchOutput) } +func (i ServiceAccountSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchPtrOutput() ServiceAccountSubjectPatchPtrOutput { return i.ToServiceAccountSubjectPatchPtrOutputWithContext(context.Background()) } @@ -5329,6 +6176,12 @@ func (i *serviceAccountSubjectPatchPtrType) ToServiceAccountSubjectPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchPtrOutput) } +func (i *serviceAccountSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectPatchOutput struct{ *pulumi.OutputState } @@ -5354,6 +6207,12 @@ func (o ServiceAccountSubjectPatchOutput) ToServiceAccountSubjectPatchPtrOutputW }).(ServiceAccountSubjectPatchPtrOutput) } +func (o ServiceAccountSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5378,6 +6237,12 @@ func (o ServiceAccountSubjectPatchPtrOutput) ToServiceAccountSubjectPatchPtrOutp return o } +func (o ServiceAccountSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPatchPtrOutput) Elem() ServiceAccountSubjectPatchOutput { return o.ApplyT(func(v *ServiceAccountSubjectPatch) ServiceAccountSubjectPatch { if v != nil { @@ -5449,6 +6314,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -5474,6 +6345,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectOutput struct{ *pulumi.OutputState } @@ -5489,6 +6366,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectOutput) Group() GroupSubjectPtrOutput { return o.ApplyT(func(v Subject) *GroupSubject { return v.Group }).(GroupSubjectPtrOutput) } @@ -5520,6 +6403,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -5567,6 +6456,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -5592,6 +6487,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -5607,6 +6508,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchOutput) Group() GroupSubjectPatchPtrOutput { return o.ApplyT(func(v SubjectPatch) *GroupSubjectPatch { return v.Group }).(GroupSubjectPatchPtrOutput) } @@ -5638,6 +6545,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] @@ -5679,6 +6592,12 @@ func (i UserSubjectArgs) ToUserSubjectOutputWithContext(ctx context.Context) Use return pulumi.ToOutputWithContext(ctx, i).(UserSubjectOutput) } +func (i UserSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: i.ToUserSubjectOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectArgs) ToUserSubjectPtrOutput() UserSubjectPtrOutput { return i.ToUserSubjectPtrOutputWithContext(context.Background()) } @@ -5720,6 +6639,12 @@ func (i *userSubjectPtrType) ToUserSubjectPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPtrOutput) } +func (i *userSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: i.ToUserSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectOutput struct{ *pulumi.OutputState } @@ -5745,6 +6670,12 @@ func (o UserSubjectOutput) ToUserSubjectPtrOutputWithContext(ctx context.Context }).(UserSubjectPtrOutput) } +func (o UserSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v UserSubject) string { return v.Name }).(pulumi.StringOutput) @@ -5764,6 +6695,12 @@ func (o UserSubjectPtrOutput) ToUserSubjectPtrOutputWithContext(ctx context.Cont return o } +func (o UserSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPtrOutput) Elem() UserSubjectOutput { return o.ApplyT(func(v *UserSubject) UserSubject { if v != nil { @@ -5819,6 +6756,12 @@ func (i UserSubjectPatchArgs) ToUserSubjectPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchOutput) } +func (i UserSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectPatchArgs) ToUserSubjectPatchPtrOutput() UserSubjectPatchPtrOutput { return i.ToUserSubjectPatchPtrOutputWithContext(context.Background()) } @@ -5860,6 +6803,12 @@ func (i *userSubjectPatchPtrType) ToUserSubjectPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchPtrOutput) } +func (i *userSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectPatchOutput struct{ *pulumi.OutputState } @@ -5885,6 +6834,12 @@ func (o UserSubjectPatchOutput) ToUserSubjectPatchPtrOutputWithContext(ctx conte }).(UserSubjectPatchPtrOutput) } +func (o UserSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v UserSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5904,6 +6859,12 @@ func (o UserSubjectPatchPtrOutput) ToUserSubjectPatchPtrOutputWithContext(ctx co return o } +func (o UserSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPatchPtrOutput) Elem() UserSubjectPatchOutput { return o.ApplyT(func(v *UserSubjectPatch) UserSubjectPatch { if v != nil { diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchema.go b/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchema.go index cdb3411190..3db9e16c1d 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchema.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchema.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". @@ -127,6 +128,12 @@ func (i *FlowSchema) ToFlowSchemaOutputWithContext(ctx context.Context) FlowSche return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaOutput) } +func (i *FlowSchema) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: i.ToFlowSchemaOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaArrayInput is an input type that accepts FlowSchemaArray and FlowSchemaArrayOutput values. // You can construct a concrete instance of `FlowSchemaArrayInput` via: // @@ -152,6 +159,12 @@ func (i FlowSchemaArray) ToFlowSchemaArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaArrayOutput) } +func (i FlowSchemaArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: i.ToFlowSchemaArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaMapInput is an input type that accepts FlowSchemaMap and FlowSchemaMapOutput values. // You can construct a concrete instance of `FlowSchemaMapInput` via: // @@ -177,6 +190,12 @@ func (i FlowSchemaMap) ToFlowSchemaMapOutputWithContext(ctx context.Context) Flo return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaMapOutput) } +func (i FlowSchemaMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: i.ToFlowSchemaMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaOutput struct{ *pulumi.OutputState } func (FlowSchemaOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o FlowSchemaOutput) ToFlowSchemaOutputWithContext(ctx context.Context) Flo return o } +func (o FlowSchemaOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchema) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o FlowSchemaArrayOutput) ToFlowSchemaArrayOutputWithContext(ctx context.Co return o } +func (o FlowSchemaArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaArrayOutput) Index(i pulumi.IntInput) FlowSchemaOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].([]*FlowSchema)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o FlowSchemaMapOutput) ToFlowSchemaMapOutputWithContext(ctx context.Contex return o } +func (o FlowSchemaMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].(map[string]*FlowSchema)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaList.go b/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaList.go index 53f2632b46..6b338b89f7 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaList.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchemaList is a list of FlowSchema objects. @@ -117,6 +118,12 @@ func (i *FlowSchemaList) ToFlowSchemaListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListOutput) } +func (i *FlowSchemaList) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListArrayInput is an input type that accepts FlowSchemaListArray and FlowSchemaListArrayOutput values. // You can construct a concrete instance of `FlowSchemaListArrayInput` via: // @@ -142,6 +149,12 @@ func (i FlowSchemaListArray) ToFlowSchemaListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListArrayOutput) } +func (i FlowSchemaListArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListMapInput is an input type that accepts FlowSchemaListMap and FlowSchemaListMapOutput values. // You can construct a concrete instance of `FlowSchemaListMapInput` via: // @@ -167,6 +180,12 @@ func (i FlowSchemaListMap) ToFlowSchemaListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListMapOutput) } +func (i FlowSchemaListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaListOutput struct{ *pulumi.OutputState } func (FlowSchemaListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o FlowSchemaListOutput) ToFlowSchemaListOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaListOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchemaList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o FlowSchemaListArrayOutput) ToFlowSchemaListArrayOutputWithContext(ctx co return o } +func (o FlowSchemaListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListArrayOutput) Index(i pulumi.IntInput) FlowSchemaListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].([]*FlowSchemaList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o FlowSchemaListMapOutput) ToFlowSchemaListMapOutputWithContext(ctx contex return o } +func (o FlowSchemaListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].(map[string]*FlowSchemaList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaPatch.go b/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaPatch.go index 7bb5484fe9..15c4f986dc 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/flowSchemaPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *FlowSchemaPatch) ToFlowSchemaPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchOutput) } +func (i *FlowSchemaPatch) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchArrayInput is an input type that accepts FlowSchemaPatchArray and FlowSchemaPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i FlowSchemaPatchArray) ToFlowSchemaPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchArrayOutput) } +func (i FlowSchemaPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchMapInput is an input type that accepts FlowSchemaPatchMap and FlowSchemaPatchMapOutput values. // You can construct a concrete instance of `FlowSchemaPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i FlowSchemaPatchMap) ToFlowSchemaPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchMapOutput) } +func (i FlowSchemaPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaPatchOutput struct{ *pulumi.OutputState } func (FlowSchemaPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o FlowSchemaPatchOutput) ToFlowSchemaPatchOutputWithContext(ctx context.Co return o } +func (o FlowSchemaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *FlowSchemaPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o FlowSchemaPatchArrayOutput) ToFlowSchemaPatchArrayOutputWithContext(ctx return o } +func (o FlowSchemaPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].([]*FlowSchemaPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o FlowSchemaPatchMapOutput) ToFlowSchemaPatchMapOutputWithContext(ctx cont return o } +func (o FlowSchemaPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].(map[string]*FlowSchemaPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfiguration.go b/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfiguration.go index c37eb63560..c72a0fad99 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfiguration.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfiguration represents the configuration of a priority level. @@ -127,6 +128,12 @@ func (i *PriorityLevelConfiguration) ToPriorityLevelConfigurationOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationOutput) } +func (i *PriorityLevelConfiguration) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationArrayInput is an input type that accepts PriorityLevelConfigurationArray and PriorityLevelConfigurationArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationArrayInput` via: // @@ -152,6 +159,12 @@ func (i PriorityLevelConfigurationArray) ToPriorityLevelConfigurationArrayOutput return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationArrayOutput) } +func (i PriorityLevelConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationMapInput is an input type that accepts PriorityLevelConfigurationMap and PriorityLevelConfigurationMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationMapInput` via: // @@ -177,6 +190,12 @@ func (i PriorityLevelConfigurationMap) ToPriorityLevelConfigurationMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationMapOutput) } +func (i PriorityLevelConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o PriorityLevelConfigurationOutput) ToPriorityLevelConfigurationOutputWith return o } +func (o PriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o PriorityLevelConfigurationArrayOutput) ToPriorityLevelConfigurationArray return o } +func (o PriorityLevelConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].([]*PriorityLevelConfiguration)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o PriorityLevelConfigurationMapOutput) ToPriorityLevelConfigurationMapOutp return o } +func (o PriorityLevelConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].(map[string]*PriorityLevelConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationList.go b/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationList.go index e024f1dd51..eeaeeb48b6 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationList.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. @@ -117,6 +118,12 @@ func (i *PriorityLevelConfigurationList) ToPriorityLevelConfigurationListOutputW return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListOutput) } +func (i *PriorityLevelConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListArrayInput is an input type that accepts PriorityLevelConfigurationListArray and PriorityLevelConfigurationListArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityLevelConfigurationListArray) ToPriorityLevelConfigurationListArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListArrayOutput) } +func (i PriorityLevelConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListMapInput is an input type that accepts PriorityLevelConfigurationListMap and PriorityLevelConfigurationListMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityLevelConfigurationListMap) ToPriorityLevelConfigurationListMapOu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListMapOutput) } +func (i PriorityLevelConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationListOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityLevelConfigurationListOutput) ToPriorityLevelConfigurationListOu return o } +func (o PriorityLevelConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityLevelConfigurationListArrayOutput) ToPriorityLevelConfigurationL return o } +func (o PriorityLevelConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].([]*PriorityLevelConfigurationList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityLevelConfigurationListMapOutput) ToPriorityLevelConfigurationLis return o } +func (o PriorityLevelConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].(map[string]*PriorityLevelConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationPatch.go b/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationPatch.go index 41e872ac5c..52e639864a 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/priorityLevelConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *PriorityLevelConfigurationPatch) ToPriorityLevelConfigurationPatchOutpu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchOutput) } +func (i *PriorityLevelConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchArrayInput is an input type that accepts PriorityLevelConfigurationPatchArray and PriorityLevelConfigurationPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i PriorityLevelConfigurationPatchArray) ToPriorityLevelConfigurationPatchA return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchArrayOutput) } +func (i PriorityLevelConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchMapInput is an input type that accepts PriorityLevelConfigurationPatchMap and PriorityLevelConfigurationPatchMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i PriorityLevelConfigurationPatchMap) ToPriorityLevelConfigurationPatchMap return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchMapOutput) } +func (i PriorityLevelConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationPatchOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o PriorityLevelConfigurationPatchOutput) ToPriorityLevelConfigurationPatch return o } +func (o PriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityLevelConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -238,6 +263,12 @@ func (o PriorityLevelConfigurationPatchArrayOutput) ToPriorityLevelConfiguration return o } +func (o PriorityLevelConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].([]*PriorityLevelConfigurationPatch)[vs[1].(int)] @@ -258,6 +289,12 @@ func (o PriorityLevelConfigurationPatchMapOutput) ToPriorityLevelConfigurationPa return o } +func (o PriorityLevelConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].(map[string]*PriorityLevelConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/flowcontrol/v1beta1/pulumiTypes.go index dc9ee33963..806410ee82 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -49,6 +50,12 @@ func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodOutput) } +func (i FlowDistinguisherMethodArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodPtrOutput() FlowDistinguisherMethodPtrOutput { return i.ToFlowDistinguisherMethodPtrOutputWithContext(context.Background()) } @@ -90,6 +97,12 @@ func (i *flowDistinguisherMethodPtrType) ToFlowDistinguisherMethodPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPtrOutput) } +func (i *flowDistinguisherMethodPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodOutput struct{ *pulumi.OutputState } @@ -115,6 +128,12 @@ func (o FlowDistinguisherMethodOutput) ToFlowDistinguisherMethodPtrOutputWithCon }).(FlowDistinguisherMethodPtrOutput) } +func (o FlowDistinguisherMethodOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodOutput) Type() pulumi.StringOutput { return o.ApplyT(func(v FlowDistinguisherMethod) string { return v.Type }).(pulumi.StringOutput) @@ -134,6 +153,12 @@ func (o FlowDistinguisherMethodPtrOutput) ToFlowDistinguisherMethodPtrOutputWith return o } +func (o FlowDistinguisherMethodPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPtrOutput) Elem() FlowDistinguisherMethodOutput { return o.ApplyT(func(v *FlowDistinguisherMethod) FlowDistinguisherMethod { if v != nil { @@ -189,6 +214,12 @@ func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchOutput) } +func (i FlowDistinguisherMethodPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchPtrOutput() FlowDistinguisherMethodPatchPtrOutput { return i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(context.Background()) } @@ -230,6 +261,12 @@ func (i *flowDistinguisherMethodPatchPtrType) ToFlowDistinguisherMethodPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchPtrOutput) } +func (i *flowDistinguisherMethodPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodPatchOutput struct{ *pulumi.OutputState } @@ -255,6 +292,12 @@ func (o FlowDistinguisherMethodPatchOutput) ToFlowDistinguisherMethodPatchPtrOut }).(FlowDistinguisherMethodPatchPtrOutput) } +func (o FlowDistinguisherMethodPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodPatchOutput) Type() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowDistinguisherMethodPatch) *string { return v.Type }).(pulumi.StringPtrOutput) @@ -274,6 +317,12 @@ func (o FlowDistinguisherMethodPatchPtrOutput) ToFlowDistinguisherMethodPatchPtr return o } +func (o FlowDistinguisherMethodPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPatchPtrOutput) Elem() FlowDistinguisherMethodPatchOutput { return o.ApplyT(func(v *FlowDistinguisherMethodPatch) FlowDistinguisherMethodPatch { if v != nil { @@ -345,6 +394,12 @@ func (i FlowSchemaTypeArgs) ToFlowSchemaTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeOutput) } +func (i FlowSchemaTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaTypeArrayInput is an input type that accepts FlowSchemaTypeArray and FlowSchemaTypeArrayOutput values. // You can construct a concrete instance of `FlowSchemaTypeArrayInput` via: // @@ -370,6 +425,12 @@ func (i FlowSchemaTypeArray) ToFlowSchemaTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeArrayOutput) } +func (i FlowSchemaTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaTypeOutput struct{ *pulumi.OutputState } @@ -385,6 +446,12 @@ func (o FlowSchemaTypeOutput) ToFlowSchemaTypeOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -424,6 +491,12 @@ func (o FlowSchemaTypeArrayOutput) ToFlowSchemaTypeArrayOutputWithContext(ctx co return o } +func (o FlowSchemaTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaTypeArrayOutput) Index(i pulumi.IntInput) FlowSchemaTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaType { return vs[0].([]FlowSchemaType)[vs[1].(int)] @@ -481,6 +554,12 @@ func (i FlowSchemaConditionArgs) ToFlowSchemaConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionOutput) } +func (i FlowSchemaConditionArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionArrayInput is an input type that accepts FlowSchemaConditionArray and FlowSchemaConditionArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionArrayInput` via: // @@ -506,6 +585,12 @@ func (i FlowSchemaConditionArray) ToFlowSchemaConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionArrayOutput) } +func (i FlowSchemaConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionOutput struct{ *pulumi.OutputState } @@ -521,6 +606,12 @@ func (o FlowSchemaConditionOutput) ToFlowSchemaConditionOutputWithContext(ctx co return o } +func (o FlowSchemaConditionOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -560,6 +651,12 @@ func (o FlowSchemaConditionArrayOutput) ToFlowSchemaConditionArrayOutputWithCont return o } +func (o FlowSchemaConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaCondition { return vs[0].([]FlowSchemaCondition)[vs[1].(int)] @@ -617,6 +714,12 @@ func (i FlowSchemaConditionPatchArgs) ToFlowSchemaConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchOutput) } +func (i FlowSchemaConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionPatchArrayInput is an input type that accepts FlowSchemaConditionPatchArray and FlowSchemaConditionPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionPatchArrayInput` via: // @@ -642,6 +745,12 @@ func (i FlowSchemaConditionPatchArray) ToFlowSchemaConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchArrayOutput) } +func (i FlowSchemaConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionPatchOutput struct{ *pulumi.OutputState } @@ -657,6 +766,12 @@ func (o FlowSchemaConditionPatchOutput) ToFlowSchemaConditionPatchOutputWithCont return o } +func (o FlowSchemaConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -696,6 +811,12 @@ func (o FlowSchemaConditionPatchArrayOutput) ToFlowSchemaConditionPatchArrayOutp return o } +func (o FlowSchemaConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaConditionPatch { return vs[0].([]FlowSchemaConditionPatch)[vs[1].(int)] @@ -749,6 +870,12 @@ func (i FlowSchemaListTypeArgs) ToFlowSchemaListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListTypeOutput) } +func (i FlowSchemaListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: i.ToFlowSchemaListTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaList is a list of FlowSchema objects. type FlowSchemaListTypeOutput struct{ *pulumi.OutputState } @@ -764,6 +891,12 @@ func (o FlowSchemaListTypeOutput) ToFlowSchemaListTypeOutputWithContext(ctx cont return o } +func (o FlowSchemaListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -835,6 +968,12 @@ func (i FlowSchemaPatchTypeArgs) ToFlowSchemaPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchTypeOutput) } +func (i FlowSchemaPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: i.ToFlowSchemaPatchTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaPatchTypeOutput struct{ *pulumi.OutputState } @@ -850,6 +989,12 @@ func (o FlowSchemaPatchTypeOutput) ToFlowSchemaPatchTypeOutputWithContext(ctx co return o } +func (o FlowSchemaPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -922,6 +1067,12 @@ func (i FlowSchemaSpecArgs) ToFlowSchemaSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecOutput) } +func (i FlowSchemaSpecArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecArgs) ToFlowSchemaSpecPtrOutput() FlowSchemaSpecPtrOutput { return i.ToFlowSchemaSpecPtrOutputWithContext(context.Background()) } @@ -963,6 +1114,12 @@ func (i *flowSchemaSpecPtrType) ToFlowSchemaSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPtrOutput) } +func (i *flowSchemaSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecOutput struct{ *pulumi.OutputState } @@ -988,6 +1145,12 @@ func (o FlowSchemaSpecOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx context.C }).(FlowSchemaSpecPtrOutput) } +func (o FlowSchemaSpecOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecOutput) DistinguisherMethod() FlowDistinguisherMethodPtrOutput { return o.ApplyT(func(v FlowSchemaSpec) *FlowDistinguisherMethod { return v.DistinguisherMethod }).(FlowDistinguisherMethodPtrOutput) @@ -1022,6 +1185,12 @@ func (o FlowSchemaSpecPtrOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx contex return o } +func (o FlowSchemaSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPtrOutput) Elem() FlowSchemaSpecOutput { return o.ApplyT(func(v *FlowSchemaSpec) FlowSchemaSpec { if v != nil { @@ -1119,6 +1288,12 @@ func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchOutput) } +func (i FlowSchemaSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchPtrOutput() FlowSchemaSpecPatchPtrOutput { return i.ToFlowSchemaSpecPatchPtrOutputWithContext(context.Background()) } @@ -1160,6 +1335,12 @@ func (i *flowSchemaSpecPatchPtrType) ToFlowSchemaSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchPtrOutput) } +func (i *flowSchemaSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecPatchOutput struct{ *pulumi.OutputState } @@ -1185,6 +1366,12 @@ func (o FlowSchemaSpecPatchOutput) ToFlowSchemaSpecPatchPtrOutputWithContext(ctx }).(FlowSchemaSpecPatchPtrOutput) } +func (o FlowSchemaSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecPatchOutput) DistinguisherMethod() FlowDistinguisherMethodPatchPtrOutput { return o.ApplyT(func(v FlowSchemaSpecPatch) *FlowDistinguisherMethodPatch { return v.DistinguisherMethod }).(FlowDistinguisherMethodPatchPtrOutput) @@ -1221,6 +1408,12 @@ func (o FlowSchemaSpecPatchPtrOutput) ToFlowSchemaSpecPatchPtrOutputWithContext( return o } +func (o FlowSchemaSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPatchPtrOutput) Elem() FlowSchemaSpecPatchOutput { return o.ApplyT(func(v *FlowSchemaSpecPatch) FlowSchemaSpecPatch { if v != nil { @@ -1306,6 +1499,12 @@ func (i FlowSchemaStatusArgs) ToFlowSchemaStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusOutput) } +func (i FlowSchemaStatusArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusArgs) ToFlowSchemaStatusPtrOutput() FlowSchemaStatusPtrOutput { return i.ToFlowSchemaStatusPtrOutputWithContext(context.Background()) } @@ -1347,6 +1546,12 @@ func (i *flowSchemaStatusPtrType) ToFlowSchemaStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPtrOutput) } +func (i *flowSchemaStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusOutput struct{ *pulumi.OutputState } @@ -1372,6 +1577,12 @@ func (o FlowSchemaStatusOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx conte }).(FlowSchemaStatusPtrOutput) } +func (o FlowSchemaStatusOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusOutput) Conditions() FlowSchemaConditionArrayOutput { return o.ApplyT(func(v FlowSchemaStatus) []FlowSchemaCondition { return v.Conditions }).(FlowSchemaConditionArrayOutput) @@ -1391,6 +1602,12 @@ func (o FlowSchemaStatusPtrOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx co return o } +func (o FlowSchemaStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPtrOutput) Elem() FlowSchemaStatusOutput { return o.ApplyT(func(v *FlowSchemaStatus) FlowSchemaStatus { if v != nil { @@ -1446,6 +1663,12 @@ func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchOutput) } +func (i FlowSchemaStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchPtrOutput() FlowSchemaStatusPatchPtrOutput { return i.ToFlowSchemaStatusPatchPtrOutputWithContext(context.Background()) } @@ -1487,6 +1710,12 @@ func (i *flowSchemaStatusPatchPtrType) ToFlowSchemaStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchPtrOutput) } +func (i *flowSchemaStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusPatchOutput struct{ *pulumi.OutputState } @@ -1512,6 +1741,12 @@ func (o FlowSchemaStatusPatchOutput) ToFlowSchemaStatusPatchPtrOutputWithContext }).(FlowSchemaStatusPatchPtrOutput) } +func (o FlowSchemaStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusPatchOutput) Conditions() FlowSchemaConditionPatchArrayOutput { return o.ApplyT(func(v FlowSchemaStatusPatch) []FlowSchemaConditionPatch { return v.Conditions }).(FlowSchemaConditionPatchArrayOutput) @@ -1531,6 +1766,12 @@ func (o FlowSchemaStatusPatchPtrOutput) ToFlowSchemaStatusPatchPtrOutputWithCont return o } +func (o FlowSchemaStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPatchPtrOutput) Elem() FlowSchemaStatusPatchOutput { return o.ApplyT(func(v *FlowSchemaStatusPatch) FlowSchemaStatusPatch { if v != nil { @@ -1586,6 +1827,12 @@ func (i GroupSubjectArgs) ToGroupSubjectOutputWithContext(ctx context.Context) G return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectOutput) } +func (i GroupSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: i.ToGroupSubjectOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectArgs) ToGroupSubjectPtrOutput() GroupSubjectPtrOutput { return i.ToGroupSubjectPtrOutputWithContext(context.Background()) } @@ -1627,6 +1874,12 @@ func (i *groupSubjectPtrType) ToGroupSubjectPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPtrOutput) } +func (i *groupSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: i.ToGroupSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectOutput struct{ *pulumi.OutputState } @@ -1652,6 +1905,12 @@ func (o GroupSubjectOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Conte }).(GroupSubjectPtrOutput) } +func (o GroupSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v GroupSubject) string { return v.Name }).(pulumi.StringOutput) @@ -1671,6 +1930,12 @@ func (o GroupSubjectPtrOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Co return o } +func (o GroupSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPtrOutput) Elem() GroupSubjectOutput { return o.ApplyT(func(v *GroupSubject) GroupSubject { if v != nil { @@ -1726,6 +1991,12 @@ func (i GroupSubjectPatchArgs) ToGroupSubjectPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchOutput) } +func (i GroupSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectPatchArgs) ToGroupSubjectPatchPtrOutput() GroupSubjectPatchPtrOutput { return i.ToGroupSubjectPatchPtrOutputWithContext(context.Background()) } @@ -1767,6 +2038,12 @@ func (i *groupSubjectPatchPtrType) ToGroupSubjectPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchPtrOutput) } +func (i *groupSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectPatchOutput struct{ *pulumi.OutputState } @@ -1792,6 +2069,12 @@ func (o GroupSubjectPatchOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx con }).(GroupSubjectPatchPtrOutput) } +func (o GroupSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v GroupSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -1811,6 +2094,12 @@ func (o GroupSubjectPatchPtrOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx return o } +func (o GroupSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPatchPtrOutput) Elem() GroupSubjectPatchOutput { return o.ApplyT(func(v *GroupSubjectPatch) GroupSubjectPatch { if v != nil { @@ -1870,6 +2159,12 @@ func (i LimitResponseArgs) ToLimitResponseOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LimitResponseOutput) } +func (i LimitResponseArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: i.ToLimitResponseOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponseArgs) ToLimitResponsePtrOutput() LimitResponsePtrOutput { return i.ToLimitResponsePtrOutputWithContext(context.Background()) } @@ -1911,6 +2206,12 @@ func (i *limitResponsePtrType) ToLimitResponsePtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePtrOutput) } +func (i *limitResponsePtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: i.ToLimitResponsePtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponseOutput struct{ *pulumi.OutputState } @@ -1936,6 +2237,12 @@ func (o LimitResponseOutput) ToLimitResponsePtrOutputWithContext(ctx context.Con }).(LimitResponsePtrOutput) } +func (o LimitResponseOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponseOutput) Queuing() QueuingConfigurationPtrOutput { return o.ApplyT(func(v LimitResponse) *QueuingConfiguration { return v.Queuing }).(QueuingConfigurationPtrOutput) @@ -1960,6 +2267,12 @@ func (o LimitResponsePtrOutput) ToLimitResponsePtrOutputWithContext(ctx context. return o } +func (o LimitResponsePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePtrOutput) Elem() LimitResponseOutput { return o.ApplyT(func(v *LimitResponse) LimitResponse { if v != nil { @@ -2029,6 +2342,12 @@ func (i LimitResponsePatchArgs) ToLimitResponsePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchOutput) } +func (i LimitResponsePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponsePatchArgs) ToLimitResponsePatchPtrOutput() LimitResponsePatchPtrOutput { return i.ToLimitResponsePatchPtrOutputWithContext(context.Background()) } @@ -2070,6 +2389,12 @@ func (i *limitResponsePatchPtrType) ToLimitResponsePatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchPtrOutput) } +func (i *limitResponsePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponsePatchOutput struct{ *pulumi.OutputState } @@ -2095,6 +2420,12 @@ func (o LimitResponsePatchOutput) ToLimitResponsePatchPtrOutputWithContext(ctx c }).(LimitResponsePatchPtrOutput) } +func (o LimitResponsePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponsePatchOutput) Queuing() QueuingConfigurationPatchPtrOutput { return o.ApplyT(func(v LimitResponsePatch) *QueuingConfigurationPatch { return v.Queuing }).(QueuingConfigurationPatchPtrOutput) @@ -2119,6 +2450,12 @@ func (o LimitResponsePatchPtrOutput) ToLimitResponsePatchPtrOutputWithContext(ct return o } +func (o LimitResponsePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePatchPtrOutput) Elem() LimitResponsePatchOutput { return o.ApplyT(func(v *LimitResponsePatch) LimitResponsePatch { if v != nil { @@ -2200,6 +2537,12 @@ func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationOutput) } +func (i LimitedPriorityLevelConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurationPtrOutput() LimitedPriorityLevelConfigurationPtrOutput { return i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(context.Background()) } @@ -2241,6 +2584,12 @@ func (i *limitedPriorityLevelConfigurationPtrType) ToLimitedPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPtrOutput) } +func (i *limitedPriorityLevelConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2268,6 +2617,12 @@ func (o LimitedPriorityLevelConfigurationOutput) ToLimitedPriorityLevelConfigura }).(LimitedPriorityLevelConfigurationPtrOutput) } +func (o LimitedPriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: // // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) @@ -2296,6 +2651,12 @@ func (o LimitedPriorityLevelConfigurationPtrOutput) ToLimitedPriorityLevelConfig return o } +func (o LimitedPriorityLevelConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPtrOutput) Elem() LimitedPriorityLevelConfigurationOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfiguration) LimitedPriorityLevelConfiguration { if v != nil { @@ -2381,6 +2742,12 @@ func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfig return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchOutput) } +func (i LimitedPriorityLevelConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfigurationPatchPtrOutput() LimitedPriorityLevelConfigurationPatchPtrOutput { return i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -2422,6 +2789,12 @@ func (i *limitedPriorityLevelConfigurationPatchPtrType) ToLimitedPriorityLevelCo return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (i *limitedPriorityLevelConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2449,6 +2822,12 @@ func (o LimitedPriorityLevelConfigurationPatchOutput) ToLimitedPriorityLevelConf }).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (o LimitedPriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: // // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) @@ -2477,6 +2856,12 @@ func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToLimitedPriorityLevelC return o } +func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPatchPtrOutput) Elem() LimitedPriorityLevelConfigurationPatchOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfigurationPatch) LimitedPriorityLevelConfigurationPatch { if v != nil { @@ -2562,6 +2947,12 @@ func (i NonResourcePolicyRuleArgs) ToNonResourcePolicyRuleOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleOutput) } +func (i NonResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRuleArrayInput is an input type that accepts NonResourcePolicyRuleArray and NonResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRuleArrayInput` via: // @@ -2587,6 +2978,12 @@ func (i NonResourcePolicyRuleArray) ToNonResourcePolicyRuleArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleArrayOutput) } +func (i NonResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -2602,6 +2999,12 @@ func (o NonResourcePolicyRuleOutput) ToNonResourcePolicyRuleOutputWithContext(ct return o } +func (o NonResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -2632,6 +3035,12 @@ func (o NonResourcePolicyRuleArrayOutput) ToNonResourcePolicyRuleArrayOutputWith return o } +func (o NonResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRule { return vs[0].([]NonResourcePolicyRule)[vs[1].(int)] @@ -2689,6 +3098,12 @@ func (i NonResourcePolicyRulePatchArgs) ToNonResourcePolicyRulePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchOutput) } +func (i NonResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRulePatchArrayInput is an input type that accepts NonResourcePolicyRulePatchArray and NonResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRulePatchArrayInput` via: // @@ -2714,6 +3129,12 @@ func (i NonResourcePolicyRulePatchArray) ToNonResourcePolicyRulePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchArrayOutput) } +func (i NonResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -2729,6 +3150,12 @@ func (o NonResourcePolicyRulePatchOutput) ToNonResourcePolicyRulePatchOutputWith return o } +func (o NonResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -2759,6 +3186,12 @@ func (o NonResourcePolicyRulePatchArrayOutput) ToNonResourcePolicyRulePatchArray return o } +func (o NonResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRulePatch { return vs[0].([]NonResourcePolicyRulePatch)[vs[1].(int)] @@ -2808,6 +3241,12 @@ func (i PolicyRulesWithSubjectsArgs) ToPolicyRulesWithSubjectsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsOutput) } +func (i PolicyRulesWithSubjectsArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsArrayInput is an input type that accepts PolicyRulesWithSubjectsArray and PolicyRulesWithSubjectsArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsArrayInput` via: // @@ -2833,6 +3272,12 @@ func (i PolicyRulesWithSubjectsArray) ToPolicyRulesWithSubjectsArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsArrayOutput) } +func (i PolicyRulesWithSubjectsArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsOutput struct{ *pulumi.OutputState } @@ -2848,6 +3293,12 @@ func (o PolicyRulesWithSubjectsOutput) ToPolicyRulesWithSubjectsOutputWithContex return o } +func (o PolicyRulesWithSubjectsOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsOutput) NonResourceRules() NonResourcePolicyRuleArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjects) []NonResourcePolicyRule { return v.NonResourceRules }).(NonResourcePolicyRuleArrayOutput) @@ -2877,6 +3328,12 @@ func (o PolicyRulesWithSubjectsArrayOutput) ToPolicyRulesWithSubjectsArrayOutput return o } +func (o PolicyRulesWithSubjectsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjects { return vs[0].([]PolicyRulesWithSubjects)[vs[1].(int)] @@ -2926,6 +3383,12 @@ func (i PolicyRulesWithSubjectsPatchArgs) ToPolicyRulesWithSubjectsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchOutput) } +func (i PolicyRulesWithSubjectsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsPatchArrayInput is an input type that accepts PolicyRulesWithSubjectsPatchArray and PolicyRulesWithSubjectsPatchArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsPatchArrayInput` via: // @@ -2951,6 +3414,12 @@ func (i PolicyRulesWithSubjectsPatchArray) ToPolicyRulesWithSubjectsPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchArrayOutput) } +func (i PolicyRulesWithSubjectsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsPatchOutput struct{ *pulumi.OutputState } @@ -2966,6 +3435,12 @@ func (o PolicyRulesWithSubjectsPatchOutput) ToPolicyRulesWithSubjectsPatchOutput return o } +func (o PolicyRulesWithSubjectsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsPatchOutput) NonResourceRules() NonResourcePolicyRulePatchArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjectsPatch) []NonResourcePolicyRulePatch { return v.NonResourceRules }).(NonResourcePolicyRulePatchArrayOutput) @@ -2995,6 +3470,12 @@ func (o PolicyRulesWithSubjectsPatchArrayOutput) ToPolicyRulesWithSubjectsPatchA return o } +func (o PolicyRulesWithSubjectsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsPatchArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjectsPatch { return vs[0].([]PolicyRulesWithSubjectsPatch)[vs[1].(int)] @@ -3052,6 +3533,12 @@ func (i PriorityLevelConfigurationTypeArgs) ToPriorityLevelConfigurationTypeOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeOutput) } +func (i PriorityLevelConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationTypeArrayInput is an input type that accepts PriorityLevelConfigurationTypeArray and PriorityLevelConfigurationTypeArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationTypeArrayInput` via: // @@ -3077,6 +3564,12 @@ func (i PriorityLevelConfigurationTypeArray) ToPriorityLevelConfigurationTypeArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeArrayOutput) } +func (i PriorityLevelConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -3092,6 +3585,12 @@ func (o PriorityLevelConfigurationTypeOutput) ToPriorityLevelConfigurationTypeOu return o } +func (o PriorityLevelConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3131,6 +3630,12 @@ func (o PriorityLevelConfigurationTypeArrayOutput) ToPriorityLevelConfigurationT return o } +func (o PriorityLevelConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationTypeArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationType { return vs[0].([]PriorityLevelConfigurationType)[vs[1].(int)] @@ -3188,6 +3693,12 @@ func (i PriorityLevelConfigurationConditionArgs) ToPriorityLevelConfigurationCon return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionOutput) } +func (i PriorityLevelConfigurationConditionArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionArrayInput is an input type that accepts PriorityLevelConfigurationConditionArray and PriorityLevelConfigurationConditionArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionArrayInput` via: // @@ -3213,6 +3724,12 @@ func (i PriorityLevelConfigurationConditionArray) ToPriorityLevelConfigurationCo return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionArrayOutput) } +func (i PriorityLevelConfigurationConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionOutput struct{ *pulumi.OutputState } @@ -3228,6 +3745,12 @@ func (o PriorityLevelConfigurationConditionOutput) ToPriorityLevelConfigurationC return o } +func (o PriorityLevelConfigurationConditionOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3267,6 +3790,12 @@ func (o PriorityLevelConfigurationConditionArrayOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationCondition { return vs[0].([]PriorityLevelConfigurationCondition)[vs[1].(int)] @@ -3324,6 +3853,12 @@ func (i PriorityLevelConfigurationConditionPatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchOutput) } +func (i PriorityLevelConfigurationConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionPatchArrayInput is an input type that accepts PriorityLevelConfigurationConditionPatchArray and PriorityLevelConfigurationConditionPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionPatchArrayInput` via: // @@ -3349,6 +3884,12 @@ func (i PriorityLevelConfigurationConditionPatchArray) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchArrayOutput) } +func (i PriorityLevelConfigurationConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionPatchOutput struct{ *pulumi.OutputState } @@ -3364,6 +3905,12 @@ func (o PriorityLevelConfigurationConditionPatchOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3403,6 +3950,12 @@ func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToPriorityLevelConf return o } +func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationConditionPatch { return vs[0].([]PriorityLevelConfigurationConditionPatch)[vs[1].(int)] @@ -3456,6 +4009,12 @@ func (i PriorityLevelConfigurationListTypeArgs) ToPriorityLevelConfigurationList return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListTypeOutput) } +func (i PriorityLevelConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: i.ToPriorityLevelConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. type PriorityLevelConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -3471,6 +4030,12 @@ func (o PriorityLevelConfigurationListTypeOutput) ToPriorityLevelConfigurationLi return o } +func (o PriorityLevelConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3542,6 +4107,12 @@ func (i PriorityLevelConfigurationPatchTypeArgs) ToPriorityLevelConfigurationPat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchTypeOutput) } +func (i PriorityLevelConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: i.ToPriorityLevelConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -3557,6 +4128,12 @@ func (o PriorityLevelConfigurationPatchTypeOutput) ToPriorityLevelConfigurationP return o } +func (o PriorityLevelConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3617,6 +4194,12 @@ func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationRef return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferenceOutput) } +func (i PriorityLevelConfigurationReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferenceOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationReferencePtrOutput() PriorityLevelConfigurationReferencePtrOutput { return i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(context.Background()) } @@ -3658,6 +4241,12 @@ func (i *priorityLevelConfigurationReferencePtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePtrOutput) } +func (i *priorityLevelConfigurationReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferenceOutput struct{ *pulumi.OutputState } @@ -3683,6 +4272,12 @@ func (o PriorityLevelConfigurationReferenceOutput) ToPriorityLevelConfigurationR }).(PriorityLevelConfigurationReferencePtrOutput) } +func (o PriorityLevelConfigurationReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PriorityLevelConfigurationReference) string { return v.Name }).(pulumi.StringOutput) @@ -3702,6 +4297,12 @@ func (o PriorityLevelConfigurationReferencePtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePtrOutput) Elem() PriorityLevelConfigurationReferenceOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReference) PriorityLevelConfigurationReference { if v != nil { @@ -3757,6 +4358,12 @@ func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchOutput) } +func (i PriorityLevelConfigurationReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurationReferencePatchPtrOutput() PriorityLevelConfigurationReferencePatchPtrOutput { return i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(context.Background()) } @@ -3798,6 +4405,12 @@ func (i *priorityLevelConfigurationReferencePatchPtrType) ToPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (i *priorityLevelConfigurationReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferencePatchOutput struct{ *pulumi.OutputState } @@ -3823,6 +4436,12 @@ func (o PriorityLevelConfigurationReferencePatchOutput) ToPriorityLevelConfigura }).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (o PriorityLevelConfigurationReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -3842,6 +4461,12 @@ func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToPriorityLevelConfig return o } +func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePatchPtrOutput) Elem() PriorityLevelConfigurationReferencePatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReferencePatch) PriorityLevelConfigurationReferencePatch { if v != nil { @@ -3901,6 +4526,12 @@ func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecOutput) } +func (i PriorityLevelConfigurationSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecPtrOutput() PriorityLevelConfigurationSpecPtrOutput { return i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(context.Background()) } @@ -3942,6 +4573,12 @@ func (i *priorityLevelConfigurationSpecPtrType) ToPriorityLevelConfigurationSpec return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPtrOutput) } +func (i *priorityLevelConfigurationSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecOutput struct{ *pulumi.OutputState } @@ -3967,6 +4604,12 @@ func (o PriorityLevelConfigurationSpecOutput) ToPriorityLevelConfigurationSpecPt }).(PriorityLevelConfigurationSpecPtrOutput) } +func (o PriorityLevelConfigurationSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + // `limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `"Limited"`. func (o PriorityLevelConfigurationSpecOutput) Limited() LimitedPriorityLevelConfigurationPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpec) *LimitedPriorityLevelConfiguration { return v.Limited }).(LimitedPriorityLevelConfigurationPtrOutput) @@ -3991,6 +4634,12 @@ func (o PriorityLevelConfigurationSpecPtrOutput) ToPriorityLevelConfigurationSpe return o } +func (o PriorityLevelConfigurationSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPtrOutput) Elem() PriorityLevelConfigurationSpecOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpec) PriorityLevelConfigurationSpec { if v != nil { @@ -4060,6 +4709,12 @@ func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpe return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchOutput) } +func (i PriorityLevelConfigurationSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpecPatchPtrOutput() PriorityLevelConfigurationSpecPatchPtrOutput { return i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(context.Background()) } @@ -4101,6 +4756,12 @@ func (i *priorityLevelConfigurationSpecPatchPtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (i *priorityLevelConfigurationSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecPatchOutput struct{ *pulumi.OutputState } @@ -4126,6 +4787,12 @@ func (o PriorityLevelConfigurationSpecPatchOutput) ToPriorityLevelConfigurationS }).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (o PriorityLevelConfigurationSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + // `limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `"Limited"`. func (o PriorityLevelConfigurationSpecPatchOutput) Limited() LimitedPriorityLevelConfigurationPatchPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpecPatch) *LimitedPriorityLevelConfigurationPatch { return v.Limited }).(LimitedPriorityLevelConfigurationPatchPtrOutput) @@ -4150,6 +4817,12 @@ func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPatchPtrOutput) Elem() PriorityLevelConfigurationSpecPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpecPatch) PriorityLevelConfigurationSpecPatch { if v != nil { @@ -4215,6 +4888,12 @@ func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatus return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusOutput) } +func (i PriorityLevelConfigurationStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatusPtrOutput() PriorityLevelConfigurationStatusPtrOutput { return i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(context.Background()) } @@ -4256,6 +4935,12 @@ func (i *priorityLevelConfigurationStatusPtrType) ToPriorityLevelConfigurationSt return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPtrOutput) } +func (i *priorityLevelConfigurationStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusOutput struct{ *pulumi.OutputState } @@ -4281,6 +4966,12 @@ func (o PriorityLevelConfigurationStatusOutput) ToPriorityLevelConfigurationStat }).(PriorityLevelConfigurationStatusPtrOutput) } +func (o PriorityLevelConfigurationStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusOutput) Conditions() PriorityLevelConfigurationConditionArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatus) []PriorityLevelConfigurationCondition { return v.Conditions }).(PriorityLevelConfigurationConditionArrayOutput) @@ -4300,6 +4991,12 @@ func (o PriorityLevelConfigurationStatusPtrOutput) ToPriorityLevelConfigurationS return o } +func (o PriorityLevelConfigurationStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPtrOutput) Elem() PriorityLevelConfigurationStatusOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatus) PriorityLevelConfigurationStatus { if v != nil { @@ -4355,6 +5052,12 @@ func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationS return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchOutput) } +func (i PriorityLevelConfigurationStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationStatusPatchPtrOutput() PriorityLevelConfigurationStatusPatchPtrOutput { return i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(context.Background()) } @@ -4396,6 +5099,12 @@ func (i *priorityLevelConfigurationStatusPatchPtrType) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (i *priorityLevelConfigurationStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusPatchOutput struct{ *pulumi.OutputState } @@ -4421,6 +5130,12 @@ func (o PriorityLevelConfigurationStatusPatchOutput) ToPriorityLevelConfiguratio }).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (o PriorityLevelConfigurationStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusPatchOutput) Conditions() PriorityLevelConfigurationConditionPatchArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatusPatch) []PriorityLevelConfigurationConditionPatch { @@ -4442,6 +5157,12 @@ func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPatchPtrOutput) Elem() PriorityLevelConfigurationStatusPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatusPatch) PriorityLevelConfigurationStatusPatch { if v != nil { @@ -4505,6 +5226,12 @@ func (i QueuingConfigurationArgs) ToQueuingConfigurationOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationOutput) } +func (i QueuingConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationArgs) ToQueuingConfigurationPtrOutput() QueuingConfigurationPtrOutput { return i.ToQueuingConfigurationPtrOutputWithContext(context.Background()) } @@ -4546,6 +5273,12 @@ func (i *queuingConfigurationPtrType) ToQueuingConfigurationPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPtrOutput) } +func (i *queuingConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationOutput struct{ *pulumi.OutputState } @@ -4571,6 +5304,12 @@ func (o QueuingConfigurationOutput) ToQueuingConfigurationPtrOutputWithContext(c }).(QueuingConfigurationPtrOutput) } +func (o QueuingConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfiguration) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -4600,6 +5339,12 @@ func (o QueuingConfigurationPtrOutput) ToQueuingConfigurationPtrOutputWithContex return o } +func (o QueuingConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPtrOutput) Elem() QueuingConfigurationOutput { return o.ApplyT(func(v *QueuingConfiguration) QueuingConfiguration { if v != nil { @@ -4683,6 +5428,12 @@ func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchOutput) } +func (i QueuingConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchPtrOutput() QueuingConfigurationPatchPtrOutput { return i.ToQueuingConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -4724,6 +5475,12 @@ func (i *queuingConfigurationPatchPtrType) ToQueuingConfigurationPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchPtrOutput) } +func (i *queuingConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationPatchOutput struct{ *pulumi.OutputState } @@ -4749,6 +5506,12 @@ func (o QueuingConfigurationPatchOutput) ToQueuingConfigurationPatchPtrOutputWit }).(QueuingConfigurationPatchPtrOutput) } +func (o QueuingConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationPatchOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfigurationPatch) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -4778,6 +5541,12 @@ func (o QueuingConfigurationPatchPtrOutput) ToQueuingConfigurationPatchPtrOutput return o } +func (o QueuingConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPatchPtrOutput) Elem() QueuingConfigurationPatchOutput { return o.ApplyT(func(v *QueuingConfigurationPatch) QueuingConfigurationPatch { if v != nil { @@ -4869,6 +5638,12 @@ func (i ResourcePolicyRuleArgs) ToResourcePolicyRuleOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleOutput) } +func (i ResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRuleArrayInput is an input type that accepts ResourcePolicyRuleArray and ResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRuleArrayInput` via: // @@ -4894,6 +5669,12 @@ func (i ResourcePolicyRuleArray) ToResourcePolicyRuleArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleArrayOutput) } +func (i ResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request. type ResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -4909,6 +5690,12 @@ func (o ResourcePolicyRuleOutput) ToResourcePolicyRuleOutputWithContext(ctx cont return o } +func (o ResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -4948,6 +5735,12 @@ func (o ResourcePolicyRuleArrayOutput) ToResourcePolicyRuleArrayOutputWithContex return o } +func (o ResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRule { return vs[0].([]ResourcePolicyRule)[vs[1].(int)] @@ -5005,6 +5798,12 @@ func (i ResourcePolicyRulePatchArgs) ToResourcePolicyRulePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchOutput) } +func (i ResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRulePatchArrayInput is an input type that accepts ResourcePolicyRulePatchArray and ResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRulePatchArrayInput` via: // @@ -5030,6 +5829,12 @@ func (i ResourcePolicyRulePatchArray) ToResourcePolicyRulePatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchArrayOutput) } +func (i ResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request. type ResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -5045,6 +5850,12 @@ func (o ResourcePolicyRulePatchOutput) ToResourcePolicyRulePatchOutputWithContex return o } +func (o ResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -5084,6 +5895,12 @@ func (o ResourcePolicyRulePatchArrayOutput) ToResourcePolicyRulePatchArrayOutput return o } +func (o ResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRulePatch { return vs[0].([]ResourcePolicyRulePatch)[vs[1].(int)] @@ -5129,6 +5946,12 @@ func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectOutput) } +func (i ServiceAccountSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectPtrOutput() ServiceAccountSubjectPtrOutput { return i.ToServiceAccountSubjectPtrOutputWithContext(context.Background()) } @@ -5170,6 +5993,12 @@ func (i *serviceAccountSubjectPtrType) ToServiceAccountSubjectPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPtrOutput) } +func (i *serviceAccountSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectOutput struct{ *pulumi.OutputState } @@ -5195,6 +6024,12 @@ func (o ServiceAccountSubjectOutput) ToServiceAccountSubjectPtrOutputWithContext }).(ServiceAccountSubjectPtrOutput) } +func (o ServiceAccountSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceAccountSubject) string { return v.Name }).(pulumi.StringOutput) @@ -5219,6 +6054,12 @@ func (o ServiceAccountSubjectPtrOutput) ToServiceAccountSubjectPtrOutputWithCont return o } +func (o ServiceAccountSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPtrOutput) Elem() ServiceAccountSubjectOutput { return o.ApplyT(func(v *ServiceAccountSubject) ServiceAccountSubject { if v != nil { @@ -5288,6 +6129,12 @@ func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchOutput) } +func (i ServiceAccountSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchPtrOutput() ServiceAccountSubjectPatchPtrOutput { return i.ToServiceAccountSubjectPatchPtrOutputWithContext(context.Background()) } @@ -5329,6 +6176,12 @@ func (i *serviceAccountSubjectPatchPtrType) ToServiceAccountSubjectPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchPtrOutput) } +func (i *serviceAccountSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectPatchOutput struct{ *pulumi.OutputState } @@ -5354,6 +6207,12 @@ func (o ServiceAccountSubjectPatchOutput) ToServiceAccountSubjectPatchPtrOutputW }).(ServiceAccountSubjectPatchPtrOutput) } +func (o ServiceAccountSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5378,6 +6237,12 @@ func (o ServiceAccountSubjectPatchPtrOutput) ToServiceAccountSubjectPatchPtrOutp return o } +func (o ServiceAccountSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPatchPtrOutput) Elem() ServiceAccountSubjectPatchOutput { return o.ApplyT(func(v *ServiceAccountSubjectPatch) ServiceAccountSubjectPatch { if v != nil { @@ -5449,6 +6314,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -5474,6 +6345,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectOutput struct{ *pulumi.OutputState } @@ -5489,6 +6366,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectOutput) Group() GroupSubjectPtrOutput { return o.ApplyT(func(v Subject) *GroupSubject { return v.Group }).(GroupSubjectPtrOutput) } @@ -5520,6 +6403,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -5567,6 +6456,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -5592,6 +6487,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -5607,6 +6508,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchOutput) Group() GroupSubjectPatchPtrOutput { return o.ApplyT(func(v SubjectPatch) *GroupSubjectPatch { return v.Group }).(GroupSubjectPatchPtrOutput) } @@ -5638,6 +6545,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] @@ -5679,6 +6592,12 @@ func (i UserSubjectArgs) ToUserSubjectOutputWithContext(ctx context.Context) Use return pulumi.ToOutputWithContext(ctx, i).(UserSubjectOutput) } +func (i UserSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: i.ToUserSubjectOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectArgs) ToUserSubjectPtrOutput() UserSubjectPtrOutput { return i.ToUserSubjectPtrOutputWithContext(context.Background()) } @@ -5720,6 +6639,12 @@ func (i *userSubjectPtrType) ToUserSubjectPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPtrOutput) } +func (i *userSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: i.ToUserSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectOutput struct{ *pulumi.OutputState } @@ -5745,6 +6670,12 @@ func (o UserSubjectOutput) ToUserSubjectPtrOutputWithContext(ctx context.Context }).(UserSubjectPtrOutput) } +func (o UserSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v UserSubject) string { return v.Name }).(pulumi.StringOutput) @@ -5764,6 +6695,12 @@ func (o UserSubjectPtrOutput) ToUserSubjectPtrOutputWithContext(ctx context.Cont return o } +func (o UserSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPtrOutput) Elem() UserSubjectOutput { return o.ApplyT(func(v *UserSubject) UserSubject { if v != nil { @@ -5819,6 +6756,12 @@ func (i UserSubjectPatchArgs) ToUserSubjectPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchOutput) } +func (i UserSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectPatchArgs) ToUserSubjectPatchPtrOutput() UserSubjectPatchPtrOutput { return i.ToUserSubjectPatchPtrOutputWithContext(context.Background()) } @@ -5860,6 +6803,12 @@ func (i *userSubjectPatchPtrType) ToUserSubjectPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchPtrOutput) } +func (i *userSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectPatchOutput struct{ *pulumi.OutputState } @@ -5885,6 +6834,12 @@ func (o UserSubjectPatchOutput) ToUserSubjectPatchPtrOutputWithContext(ctx conte }).(UserSubjectPatchPtrOutput) } +func (o UserSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v UserSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5904,6 +6859,12 @@ func (o UserSubjectPatchPtrOutput) ToUserSubjectPatchPtrOutputWithContext(ctx co return o } +func (o UserSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPatchPtrOutput) Elem() UserSubjectPatchOutput { return o.ApplyT(func(v *UserSubjectPatch) UserSubjectPatch { if v != nil { diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchema.go b/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchema.go index 7cf039a4c0..0cf64a709c 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchema.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchema.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". @@ -127,6 +128,12 @@ func (i *FlowSchema) ToFlowSchemaOutputWithContext(ctx context.Context) FlowSche return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaOutput) } +func (i *FlowSchema) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: i.ToFlowSchemaOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaArrayInput is an input type that accepts FlowSchemaArray and FlowSchemaArrayOutput values. // You can construct a concrete instance of `FlowSchemaArrayInput` via: // @@ -152,6 +159,12 @@ func (i FlowSchemaArray) ToFlowSchemaArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaArrayOutput) } +func (i FlowSchemaArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: i.ToFlowSchemaArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaMapInput is an input type that accepts FlowSchemaMap and FlowSchemaMapOutput values. // You can construct a concrete instance of `FlowSchemaMapInput` via: // @@ -177,6 +190,12 @@ func (i FlowSchemaMap) ToFlowSchemaMapOutputWithContext(ctx context.Context) Flo return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaMapOutput) } +func (i FlowSchemaMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: i.ToFlowSchemaMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaOutput struct{ *pulumi.OutputState } func (FlowSchemaOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o FlowSchemaOutput) ToFlowSchemaOutputWithContext(ctx context.Context) Flo return o } +func (o FlowSchemaOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchema) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o FlowSchemaArrayOutput) ToFlowSchemaArrayOutputWithContext(ctx context.Co return o } +func (o FlowSchemaArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaArrayOutput) Index(i pulumi.IntInput) FlowSchemaOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].([]*FlowSchema)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o FlowSchemaMapOutput) ToFlowSchemaMapOutputWithContext(ctx context.Contex return o } +func (o FlowSchemaMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].(map[string]*FlowSchema)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaList.go b/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaList.go index 80968ade11..5b2c910d48 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaList.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchemaList is a list of FlowSchema objects. @@ -117,6 +118,12 @@ func (i *FlowSchemaList) ToFlowSchemaListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListOutput) } +func (i *FlowSchemaList) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListArrayInput is an input type that accepts FlowSchemaListArray and FlowSchemaListArrayOutput values. // You can construct a concrete instance of `FlowSchemaListArrayInput` via: // @@ -142,6 +149,12 @@ func (i FlowSchemaListArray) ToFlowSchemaListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListArrayOutput) } +func (i FlowSchemaListArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListMapInput is an input type that accepts FlowSchemaListMap and FlowSchemaListMapOutput values. // You can construct a concrete instance of `FlowSchemaListMapInput` via: // @@ -167,6 +180,12 @@ func (i FlowSchemaListMap) ToFlowSchemaListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListMapOutput) } +func (i FlowSchemaListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaListOutput struct{ *pulumi.OutputState } func (FlowSchemaListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o FlowSchemaListOutput) ToFlowSchemaListOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaListOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchemaList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o FlowSchemaListArrayOutput) ToFlowSchemaListArrayOutputWithContext(ctx co return o } +func (o FlowSchemaListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListArrayOutput) Index(i pulumi.IntInput) FlowSchemaListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].([]*FlowSchemaList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o FlowSchemaListMapOutput) ToFlowSchemaListMapOutputWithContext(ctx contex return o } +func (o FlowSchemaListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].(map[string]*FlowSchemaList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaPatch.go b/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaPatch.go index 6552b8a8e9..03bb8598bd 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/flowSchemaPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *FlowSchemaPatch) ToFlowSchemaPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchOutput) } +func (i *FlowSchemaPatch) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchArrayInput is an input type that accepts FlowSchemaPatchArray and FlowSchemaPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i FlowSchemaPatchArray) ToFlowSchemaPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchArrayOutput) } +func (i FlowSchemaPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchMapInput is an input type that accepts FlowSchemaPatchMap and FlowSchemaPatchMapOutput values. // You can construct a concrete instance of `FlowSchemaPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i FlowSchemaPatchMap) ToFlowSchemaPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchMapOutput) } +func (i FlowSchemaPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaPatchOutput struct{ *pulumi.OutputState } func (FlowSchemaPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o FlowSchemaPatchOutput) ToFlowSchemaPatchOutputWithContext(ctx context.Co return o } +func (o FlowSchemaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *FlowSchemaPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o FlowSchemaPatchArrayOutput) ToFlowSchemaPatchArrayOutputWithContext(ctx return o } +func (o FlowSchemaPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].([]*FlowSchemaPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o FlowSchemaPatchMapOutput) ToFlowSchemaPatchMapOutputWithContext(ctx cont return o } +func (o FlowSchemaPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].(map[string]*FlowSchemaPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfiguration.go b/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfiguration.go index 94a08aecd1..d2facd45b2 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfiguration.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfiguration represents the configuration of a priority level. @@ -127,6 +128,12 @@ func (i *PriorityLevelConfiguration) ToPriorityLevelConfigurationOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationOutput) } +func (i *PriorityLevelConfiguration) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationArrayInput is an input type that accepts PriorityLevelConfigurationArray and PriorityLevelConfigurationArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationArrayInput` via: // @@ -152,6 +159,12 @@ func (i PriorityLevelConfigurationArray) ToPriorityLevelConfigurationArrayOutput return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationArrayOutput) } +func (i PriorityLevelConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationMapInput is an input type that accepts PriorityLevelConfigurationMap and PriorityLevelConfigurationMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationMapInput` via: // @@ -177,6 +190,12 @@ func (i PriorityLevelConfigurationMap) ToPriorityLevelConfigurationMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationMapOutput) } +func (i PriorityLevelConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o PriorityLevelConfigurationOutput) ToPriorityLevelConfigurationOutputWith return o } +func (o PriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o PriorityLevelConfigurationArrayOutput) ToPriorityLevelConfigurationArray return o } +func (o PriorityLevelConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].([]*PriorityLevelConfiguration)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o PriorityLevelConfigurationMapOutput) ToPriorityLevelConfigurationMapOutp return o } +func (o PriorityLevelConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].(map[string]*PriorityLevelConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationList.go b/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationList.go index d1b9222008..13c222a452 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationList.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. @@ -117,6 +118,12 @@ func (i *PriorityLevelConfigurationList) ToPriorityLevelConfigurationListOutputW return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListOutput) } +func (i *PriorityLevelConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListArrayInput is an input type that accepts PriorityLevelConfigurationListArray and PriorityLevelConfigurationListArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityLevelConfigurationListArray) ToPriorityLevelConfigurationListArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListArrayOutput) } +func (i PriorityLevelConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListMapInput is an input type that accepts PriorityLevelConfigurationListMap and PriorityLevelConfigurationListMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityLevelConfigurationListMap) ToPriorityLevelConfigurationListMapOu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListMapOutput) } +func (i PriorityLevelConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationListOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityLevelConfigurationListOutput) ToPriorityLevelConfigurationListOu return o } +func (o PriorityLevelConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityLevelConfigurationListArrayOutput) ToPriorityLevelConfigurationL return o } +func (o PriorityLevelConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].([]*PriorityLevelConfigurationList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityLevelConfigurationListMapOutput) ToPriorityLevelConfigurationLis return o } +func (o PriorityLevelConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].(map[string]*PriorityLevelConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationPatch.go b/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationPatch.go index ef3e86bbdd..94ccf6d675 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/priorityLevelConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *PriorityLevelConfigurationPatch) ToPriorityLevelConfigurationPatchOutpu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchOutput) } +func (i *PriorityLevelConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchArrayInput is an input type that accepts PriorityLevelConfigurationPatchArray and PriorityLevelConfigurationPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i PriorityLevelConfigurationPatchArray) ToPriorityLevelConfigurationPatchA return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchArrayOutput) } +func (i PriorityLevelConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchMapInput is an input type that accepts PriorityLevelConfigurationPatchMap and PriorityLevelConfigurationPatchMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i PriorityLevelConfigurationPatchMap) ToPriorityLevelConfigurationPatchMap return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchMapOutput) } +func (i PriorityLevelConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationPatchOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o PriorityLevelConfigurationPatchOutput) ToPriorityLevelConfigurationPatch return o } +func (o PriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityLevelConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -238,6 +263,12 @@ func (o PriorityLevelConfigurationPatchArrayOutput) ToPriorityLevelConfiguration return o } +func (o PriorityLevelConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].([]*PriorityLevelConfigurationPatch)[vs[1].(int)] @@ -258,6 +289,12 @@ func (o PriorityLevelConfigurationPatchMapOutput) ToPriorityLevelConfigurationPa return o } +func (o PriorityLevelConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].(map[string]*PriorityLevelConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta2/pulumiTypes.go b/sdk/go/kubernetes/flowcontrol/v1beta2/pulumiTypes.go index e791c1b861..eea595c1b9 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta2/pulumiTypes.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta2/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -65,6 +66,12 @@ func (i ExemptPriorityLevelConfigurationArgs) ToExemptPriorityLevelConfiguration return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationOutput) } +func (i ExemptPriorityLevelConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfiguration] { + return pulumix.Output[ExemptPriorityLevelConfiguration]{ + OutputState: i.ToExemptPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i ExemptPriorityLevelConfigurationArgs) ToExemptPriorityLevelConfigurationPtrOutput() ExemptPriorityLevelConfigurationPtrOutput { return i.ToExemptPriorityLevelConfigurationPtrOutputWithContext(context.Background()) } @@ -106,6 +113,12 @@ func (i *exemptPriorityLevelConfigurationPtrType) ToExemptPriorityLevelConfigura return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationPtrOutput) } +func (i *exemptPriorityLevelConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfiguration] { + return pulumix.Output[*ExemptPriorityLevelConfiguration]{ + OutputState: i.ToExemptPriorityLevelConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // ExemptPriorityLevelConfiguration describes the configurable aspects of the handling of exempt requests. In the mandatory exempt configuration object the values in the fields here can be modified by authorized users, unlike the rest of the `spec`. type ExemptPriorityLevelConfigurationOutput struct{ *pulumi.OutputState } @@ -131,6 +144,12 @@ func (o ExemptPriorityLevelConfigurationOutput) ToExemptPriorityLevelConfigurati }).(ExemptPriorityLevelConfigurationPtrOutput) } +func (o ExemptPriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfiguration] { + return pulumix.Output[ExemptPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // `lendablePercent` prescribes the fraction of the level's NominalCL that can be borrowed by other priority levels. This value of this field must be between 0 and 100, inclusive, and it defaults to 0. The number of seats that other levels can borrow from this level, known as this level's LendableConcurrencyLimit (LendableCL), is defined as follows. // // LendableCL(i) = round( NominalCL(i) * lendablePercent(i)/100.0 ) @@ -161,6 +180,12 @@ func (o ExemptPriorityLevelConfigurationPtrOutput) ToExemptPriorityLevelConfigur return o } +func (o ExemptPriorityLevelConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfiguration] { + return pulumix.Output[*ExemptPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o ExemptPriorityLevelConfigurationPtrOutput) Elem() ExemptPriorityLevelConfigurationOutput { return o.ApplyT(func(v *ExemptPriorityLevelConfiguration) ExemptPriorityLevelConfiguration { if v != nil { @@ -248,6 +273,12 @@ func (i ExemptPriorityLevelConfigurationPatchArgs) ToExemptPriorityLevelConfigur return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationPatchOutput) } +func (i ExemptPriorityLevelConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[ExemptPriorityLevelConfigurationPatch]{ + OutputState: i.ToExemptPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExemptPriorityLevelConfigurationPatchArgs) ToExemptPriorityLevelConfigurationPatchPtrOutput() ExemptPriorityLevelConfigurationPatchPtrOutput { return i.ToExemptPriorityLevelConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -289,6 +320,12 @@ func (i *exemptPriorityLevelConfigurationPatchPtrType) ToExemptPriorityLevelConf return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationPatchPtrOutput) } +func (i *exemptPriorityLevelConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[*ExemptPriorityLevelConfigurationPatch]{ + OutputState: i.ToExemptPriorityLevelConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExemptPriorityLevelConfiguration describes the configurable aspects of the handling of exempt requests. In the mandatory exempt configuration object the values in the fields here can be modified by authorized users, unlike the rest of the `spec`. type ExemptPriorityLevelConfigurationPatchOutput struct{ *pulumi.OutputState } @@ -314,6 +351,12 @@ func (o ExemptPriorityLevelConfigurationPatchOutput) ToExemptPriorityLevelConfig }).(ExemptPriorityLevelConfigurationPatchPtrOutput) } +func (o ExemptPriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[ExemptPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `lendablePercent` prescribes the fraction of the level's NominalCL that can be borrowed by other priority levels. This value of this field must be between 0 and 100, inclusive, and it defaults to 0. The number of seats that other levels can borrow from this level, known as this level's LendableConcurrencyLimit (LendableCL), is defined as follows. // // LendableCL(i) = round( NominalCL(i) * lendablePercent(i)/100.0 ) @@ -344,6 +387,12 @@ func (o ExemptPriorityLevelConfigurationPatchPtrOutput) ToExemptPriorityLevelCon return o } +func (o ExemptPriorityLevelConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[*ExemptPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o ExemptPriorityLevelConfigurationPatchPtrOutput) Elem() ExemptPriorityLevelConfigurationPatchOutput { return o.ApplyT(func(v *ExemptPriorityLevelConfigurationPatch) ExemptPriorityLevelConfigurationPatch { if v != nil { @@ -415,6 +464,12 @@ func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodOutput) } +func (i FlowDistinguisherMethodArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodPtrOutput() FlowDistinguisherMethodPtrOutput { return i.ToFlowDistinguisherMethodPtrOutputWithContext(context.Background()) } @@ -456,6 +511,12 @@ func (i *flowDistinguisherMethodPtrType) ToFlowDistinguisherMethodPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPtrOutput) } +func (i *flowDistinguisherMethodPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodOutput struct{ *pulumi.OutputState } @@ -481,6 +542,12 @@ func (o FlowDistinguisherMethodOutput) ToFlowDistinguisherMethodPtrOutputWithCon }).(FlowDistinguisherMethodPtrOutput) } +func (o FlowDistinguisherMethodOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodOutput) Type() pulumi.StringOutput { return o.ApplyT(func(v FlowDistinguisherMethod) string { return v.Type }).(pulumi.StringOutput) @@ -500,6 +567,12 @@ func (o FlowDistinguisherMethodPtrOutput) ToFlowDistinguisherMethodPtrOutputWith return o } +func (o FlowDistinguisherMethodPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPtrOutput) Elem() FlowDistinguisherMethodOutput { return o.ApplyT(func(v *FlowDistinguisherMethod) FlowDistinguisherMethod { if v != nil { @@ -555,6 +628,12 @@ func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchOutput) } +func (i FlowDistinguisherMethodPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchPtrOutput() FlowDistinguisherMethodPatchPtrOutput { return i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(context.Background()) } @@ -596,6 +675,12 @@ func (i *flowDistinguisherMethodPatchPtrType) ToFlowDistinguisherMethodPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchPtrOutput) } +func (i *flowDistinguisherMethodPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodPatchOutput struct{ *pulumi.OutputState } @@ -621,6 +706,12 @@ func (o FlowDistinguisherMethodPatchOutput) ToFlowDistinguisherMethodPatchPtrOut }).(FlowDistinguisherMethodPatchPtrOutput) } +func (o FlowDistinguisherMethodPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodPatchOutput) Type() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowDistinguisherMethodPatch) *string { return v.Type }).(pulumi.StringPtrOutput) @@ -640,6 +731,12 @@ func (o FlowDistinguisherMethodPatchPtrOutput) ToFlowDistinguisherMethodPatchPtr return o } +func (o FlowDistinguisherMethodPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPatchPtrOutput) Elem() FlowDistinguisherMethodPatchOutput { return o.ApplyT(func(v *FlowDistinguisherMethodPatch) FlowDistinguisherMethodPatch { if v != nil { @@ -711,6 +808,12 @@ func (i FlowSchemaTypeArgs) ToFlowSchemaTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeOutput) } +func (i FlowSchemaTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaTypeArrayInput is an input type that accepts FlowSchemaTypeArray and FlowSchemaTypeArrayOutput values. // You can construct a concrete instance of `FlowSchemaTypeArrayInput` via: // @@ -736,6 +839,12 @@ func (i FlowSchemaTypeArray) ToFlowSchemaTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeArrayOutput) } +func (i FlowSchemaTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaTypeOutput struct{ *pulumi.OutputState } @@ -751,6 +860,12 @@ func (o FlowSchemaTypeOutput) ToFlowSchemaTypeOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -790,6 +905,12 @@ func (o FlowSchemaTypeArrayOutput) ToFlowSchemaTypeArrayOutputWithContext(ctx co return o } +func (o FlowSchemaTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaTypeArrayOutput) Index(i pulumi.IntInput) FlowSchemaTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaType { return vs[0].([]FlowSchemaType)[vs[1].(int)] @@ -847,6 +968,12 @@ func (i FlowSchemaConditionArgs) ToFlowSchemaConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionOutput) } +func (i FlowSchemaConditionArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionArrayInput is an input type that accepts FlowSchemaConditionArray and FlowSchemaConditionArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionArrayInput` via: // @@ -872,6 +999,12 @@ func (i FlowSchemaConditionArray) ToFlowSchemaConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionArrayOutput) } +func (i FlowSchemaConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionOutput struct{ *pulumi.OutputState } @@ -887,6 +1020,12 @@ func (o FlowSchemaConditionOutput) ToFlowSchemaConditionOutputWithContext(ctx co return o } +func (o FlowSchemaConditionOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -926,6 +1065,12 @@ func (o FlowSchemaConditionArrayOutput) ToFlowSchemaConditionArrayOutputWithCont return o } +func (o FlowSchemaConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaCondition { return vs[0].([]FlowSchemaCondition)[vs[1].(int)] @@ -983,6 +1128,12 @@ func (i FlowSchemaConditionPatchArgs) ToFlowSchemaConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchOutput) } +func (i FlowSchemaConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionPatchArrayInput is an input type that accepts FlowSchemaConditionPatchArray and FlowSchemaConditionPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionPatchArrayInput` via: // @@ -1008,6 +1159,12 @@ func (i FlowSchemaConditionPatchArray) ToFlowSchemaConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchArrayOutput) } +func (i FlowSchemaConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionPatchOutput struct{ *pulumi.OutputState } @@ -1023,6 +1180,12 @@ func (o FlowSchemaConditionPatchOutput) ToFlowSchemaConditionPatchOutputWithCont return o } +func (o FlowSchemaConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -1062,6 +1225,12 @@ func (o FlowSchemaConditionPatchArrayOutput) ToFlowSchemaConditionPatchArrayOutp return o } +func (o FlowSchemaConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaConditionPatch { return vs[0].([]FlowSchemaConditionPatch)[vs[1].(int)] @@ -1115,6 +1284,12 @@ func (i FlowSchemaListTypeArgs) ToFlowSchemaListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListTypeOutput) } +func (i FlowSchemaListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: i.ToFlowSchemaListTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaList is a list of FlowSchema objects. type FlowSchemaListTypeOutput struct{ *pulumi.OutputState } @@ -1130,6 +1305,12 @@ func (o FlowSchemaListTypeOutput) ToFlowSchemaListTypeOutputWithContext(ctx cont return o } +func (o FlowSchemaListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1201,6 +1382,12 @@ func (i FlowSchemaPatchTypeArgs) ToFlowSchemaPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchTypeOutput) } +func (i FlowSchemaPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: i.ToFlowSchemaPatchTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaPatchTypeOutput struct{ *pulumi.OutputState } @@ -1216,6 +1403,12 @@ func (o FlowSchemaPatchTypeOutput) ToFlowSchemaPatchTypeOutputWithContext(ctx co return o } +func (o FlowSchemaPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1288,6 +1481,12 @@ func (i FlowSchemaSpecArgs) ToFlowSchemaSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecOutput) } +func (i FlowSchemaSpecArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecArgs) ToFlowSchemaSpecPtrOutput() FlowSchemaSpecPtrOutput { return i.ToFlowSchemaSpecPtrOutputWithContext(context.Background()) } @@ -1329,6 +1528,12 @@ func (i *flowSchemaSpecPtrType) ToFlowSchemaSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPtrOutput) } +func (i *flowSchemaSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecOutput struct{ *pulumi.OutputState } @@ -1354,6 +1559,12 @@ func (o FlowSchemaSpecOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx context.C }).(FlowSchemaSpecPtrOutput) } +func (o FlowSchemaSpecOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecOutput) DistinguisherMethod() FlowDistinguisherMethodPtrOutput { return o.ApplyT(func(v FlowSchemaSpec) *FlowDistinguisherMethod { return v.DistinguisherMethod }).(FlowDistinguisherMethodPtrOutput) @@ -1388,6 +1599,12 @@ func (o FlowSchemaSpecPtrOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx contex return o } +func (o FlowSchemaSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPtrOutput) Elem() FlowSchemaSpecOutput { return o.ApplyT(func(v *FlowSchemaSpec) FlowSchemaSpec { if v != nil { @@ -1485,6 +1702,12 @@ func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchOutput) } +func (i FlowSchemaSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchPtrOutput() FlowSchemaSpecPatchPtrOutput { return i.ToFlowSchemaSpecPatchPtrOutputWithContext(context.Background()) } @@ -1526,6 +1749,12 @@ func (i *flowSchemaSpecPatchPtrType) ToFlowSchemaSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchPtrOutput) } +func (i *flowSchemaSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecPatchOutput struct{ *pulumi.OutputState } @@ -1551,6 +1780,12 @@ func (o FlowSchemaSpecPatchOutput) ToFlowSchemaSpecPatchPtrOutputWithContext(ctx }).(FlowSchemaSpecPatchPtrOutput) } +func (o FlowSchemaSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecPatchOutput) DistinguisherMethod() FlowDistinguisherMethodPatchPtrOutput { return o.ApplyT(func(v FlowSchemaSpecPatch) *FlowDistinguisherMethodPatch { return v.DistinguisherMethod }).(FlowDistinguisherMethodPatchPtrOutput) @@ -1587,6 +1822,12 @@ func (o FlowSchemaSpecPatchPtrOutput) ToFlowSchemaSpecPatchPtrOutputWithContext( return o } +func (o FlowSchemaSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPatchPtrOutput) Elem() FlowSchemaSpecPatchOutput { return o.ApplyT(func(v *FlowSchemaSpecPatch) FlowSchemaSpecPatch { if v != nil { @@ -1672,6 +1913,12 @@ func (i FlowSchemaStatusArgs) ToFlowSchemaStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusOutput) } +func (i FlowSchemaStatusArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusArgs) ToFlowSchemaStatusPtrOutput() FlowSchemaStatusPtrOutput { return i.ToFlowSchemaStatusPtrOutputWithContext(context.Background()) } @@ -1713,6 +1960,12 @@ func (i *flowSchemaStatusPtrType) ToFlowSchemaStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPtrOutput) } +func (i *flowSchemaStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusOutput struct{ *pulumi.OutputState } @@ -1738,6 +1991,12 @@ func (o FlowSchemaStatusOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx conte }).(FlowSchemaStatusPtrOutput) } +func (o FlowSchemaStatusOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusOutput) Conditions() FlowSchemaConditionArrayOutput { return o.ApplyT(func(v FlowSchemaStatus) []FlowSchemaCondition { return v.Conditions }).(FlowSchemaConditionArrayOutput) @@ -1757,6 +2016,12 @@ func (o FlowSchemaStatusPtrOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx co return o } +func (o FlowSchemaStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPtrOutput) Elem() FlowSchemaStatusOutput { return o.ApplyT(func(v *FlowSchemaStatus) FlowSchemaStatus { if v != nil { @@ -1812,6 +2077,12 @@ func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchOutput) } +func (i FlowSchemaStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchPtrOutput() FlowSchemaStatusPatchPtrOutput { return i.ToFlowSchemaStatusPatchPtrOutputWithContext(context.Background()) } @@ -1853,6 +2124,12 @@ func (i *flowSchemaStatusPatchPtrType) ToFlowSchemaStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchPtrOutput) } +func (i *flowSchemaStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusPatchOutput struct{ *pulumi.OutputState } @@ -1878,6 +2155,12 @@ func (o FlowSchemaStatusPatchOutput) ToFlowSchemaStatusPatchPtrOutputWithContext }).(FlowSchemaStatusPatchPtrOutput) } +func (o FlowSchemaStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusPatchOutput) Conditions() FlowSchemaConditionPatchArrayOutput { return o.ApplyT(func(v FlowSchemaStatusPatch) []FlowSchemaConditionPatch { return v.Conditions }).(FlowSchemaConditionPatchArrayOutput) @@ -1897,6 +2180,12 @@ func (o FlowSchemaStatusPatchPtrOutput) ToFlowSchemaStatusPatchPtrOutputWithCont return o } +func (o FlowSchemaStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPatchPtrOutput) Elem() FlowSchemaStatusPatchOutput { return o.ApplyT(func(v *FlowSchemaStatusPatch) FlowSchemaStatusPatch { if v != nil { @@ -1952,6 +2241,12 @@ func (i GroupSubjectArgs) ToGroupSubjectOutputWithContext(ctx context.Context) G return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectOutput) } +func (i GroupSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: i.ToGroupSubjectOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectArgs) ToGroupSubjectPtrOutput() GroupSubjectPtrOutput { return i.ToGroupSubjectPtrOutputWithContext(context.Background()) } @@ -1993,6 +2288,12 @@ func (i *groupSubjectPtrType) ToGroupSubjectPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPtrOutput) } +func (i *groupSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: i.ToGroupSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectOutput struct{ *pulumi.OutputState } @@ -2018,6 +2319,12 @@ func (o GroupSubjectOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Conte }).(GroupSubjectPtrOutput) } +func (o GroupSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v GroupSubject) string { return v.Name }).(pulumi.StringOutput) @@ -2037,6 +2344,12 @@ func (o GroupSubjectPtrOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Co return o } +func (o GroupSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPtrOutput) Elem() GroupSubjectOutput { return o.ApplyT(func(v *GroupSubject) GroupSubject { if v != nil { @@ -2092,6 +2405,12 @@ func (i GroupSubjectPatchArgs) ToGroupSubjectPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchOutput) } +func (i GroupSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectPatchArgs) ToGroupSubjectPatchPtrOutput() GroupSubjectPatchPtrOutput { return i.ToGroupSubjectPatchPtrOutputWithContext(context.Background()) } @@ -2133,6 +2452,12 @@ func (i *groupSubjectPatchPtrType) ToGroupSubjectPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchPtrOutput) } +func (i *groupSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectPatchOutput struct{ *pulumi.OutputState } @@ -2158,6 +2483,12 @@ func (o GroupSubjectPatchOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx con }).(GroupSubjectPatchPtrOutput) } +func (o GroupSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v GroupSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -2177,6 +2508,12 @@ func (o GroupSubjectPatchPtrOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx return o } +func (o GroupSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPatchPtrOutput) Elem() GroupSubjectPatchOutput { return o.ApplyT(func(v *GroupSubjectPatch) GroupSubjectPatch { if v != nil { @@ -2236,6 +2573,12 @@ func (i LimitResponseArgs) ToLimitResponseOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LimitResponseOutput) } +func (i LimitResponseArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: i.ToLimitResponseOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponseArgs) ToLimitResponsePtrOutput() LimitResponsePtrOutput { return i.ToLimitResponsePtrOutputWithContext(context.Background()) } @@ -2277,6 +2620,12 @@ func (i *limitResponsePtrType) ToLimitResponsePtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePtrOutput) } +func (i *limitResponsePtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: i.ToLimitResponsePtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponseOutput struct{ *pulumi.OutputState } @@ -2302,6 +2651,12 @@ func (o LimitResponseOutput) ToLimitResponsePtrOutputWithContext(ctx context.Con }).(LimitResponsePtrOutput) } +func (o LimitResponseOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponseOutput) Queuing() QueuingConfigurationPtrOutput { return o.ApplyT(func(v LimitResponse) *QueuingConfiguration { return v.Queuing }).(QueuingConfigurationPtrOutput) @@ -2326,6 +2681,12 @@ func (o LimitResponsePtrOutput) ToLimitResponsePtrOutputWithContext(ctx context. return o } +func (o LimitResponsePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePtrOutput) Elem() LimitResponseOutput { return o.ApplyT(func(v *LimitResponse) LimitResponse { if v != nil { @@ -2395,6 +2756,12 @@ func (i LimitResponsePatchArgs) ToLimitResponsePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchOutput) } +func (i LimitResponsePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponsePatchArgs) ToLimitResponsePatchPtrOutput() LimitResponsePatchPtrOutput { return i.ToLimitResponsePatchPtrOutputWithContext(context.Background()) } @@ -2436,6 +2803,12 @@ func (i *limitResponsePatchPtrType) ToLimitResponsePatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchPtrOutput) } +func (i *limitResponsePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponsePatchOutput struct{ *pulumi.OutputState } @@ -2461,6 +2834,12 @@ func (o LimitResponsePatchOutput) ToLimitResponsePatchPtrOutputWithContext(ctx c }).(LimitResponsePatchPtrOutput) } +func (o LimitResponsePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponsePatchOutput) Queuing() QueuingConfigurationPatchPtrOutput { return o.ApplyT(func(v LimitResponsePatch) *QueuingConfigurationPatch { return v.Queuing }).(QueuingConfigurationPatchPtrOutput) @@ -2485,6 +2864,12 @@ func (o LimitResponsePatchPtrOutput) ToLimitResponsePatchPtrOutputWithContext(ct return o } +func (o LimitResponsePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePatchPtrOutput) Elem() LimitResponsePatchOutput { return o.ApplyT(func(v *LimitResponsePatch) LimitResponsePatch { if v != nil { @@ -2586,6 +2971,12 @@ func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationOutput) } +func (i LimitedPriorityLevelConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurationPtrOutput() LimitedPriorityLevelConfigurationPtrOutput { return i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(context.Background()) } @@ -2627,6 +3018,12 @@ func (i *limitedPriorityLevelConfigurationPtrType) ToLimitedPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPtrOutput) } +func (i *limitedPriorityLevelConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2654,6 +3051,12 @@ func (o LimitedPriorityLevelConfigurationOutput) ToLimitedPriorityLevelConfigura }).(LimitedPriorityLevelConfigurationPtrOutput) } +func (o LimitedPriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: // // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) @@ -2698,6 +3101,12 @@ func (o LimitedPriorityLevelConfigurationPtrOutput) ToLimitedPriorityLevelConfig return o } +func (o LimitedPriorityLevelConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPtrOutput) Elem() LimitedPriorityLevelConfigurationOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfiguration) LimitedPriorityLevelConfiguration { if v != nil { @@ -2829,6 +3238,12 @@ func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfig return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchOutput) } +func (i LimitedPriorityLevelConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfigurationPatchPtrOutput() LimitedPriorityLevelConfigurationPatchPtrOutput { return i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -2870,6 +3285,12 @@ func (i *limitedPriorityLevelConfigurationPatchPtrType) ToLimitedPriorityLevelCo return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (i *limitedPriorityLevelConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2897,6 +3318,12 @@ func (o LimitedPriorityLevelConfigurationPatchOutput) ToLimitedPriorityLevelConf }).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (o LimitedPriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: // // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) @@ -2941,6 +3368,12 @@ func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToLimitedPriorityLevelC return o } +func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPatchPtrOutput) Elem() LimitedPriorityLevelConfigurationPatchOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfigurationPatch) LimitedPriorityLevelConfigurationPatch { if v != nil { @@ -3052,6 +3485,12 @@ func (i NonResourcePolicyRuleArgs) ToNonResourcePolicyRuleOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleOutput) } +func (i NonResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRuleArrayInput is an input type that accepts NonResourcePolicyRuleArray and NonResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRuleArrayInput` via: // @@ -3077,6 +3516,12 @@ func (i NonResourcePolicyRuleArray) ToNonResourcePolicyRuleArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleArrayOutput) } +func (i NonResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -3092,6 +3537,12 @@ func (o NonResourcePolicyRuleOutput) ToNonResourcePolicyRuleOutputWithContext(ct return o } +func (o NonResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -3122,6 +3573,12 @@ func (o NonResourcePolicyRuleArrayOutput) ToNonResourcePolicyRuleArrayOutputWith return o } +func (o NonResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRule { return vs[0].([]NonResourcePolicyRule)[vs[1].(int)] @@ -3179,6 +3636,12 @@ func (i NonResourcePolicyRulePatchArgs) ToNonResourcePolicyRulePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchOutput) } +func (i NonResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRulePatchArrayInput is an input type that accepts NonResourcePolicyRulePatchArray and NonResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRulePatchArrayInput` via: // @@ -3204,6 +3667,12 @@ func (i NonResourcePolicyRulePatchArray) ToNonResourcePolicyRulePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchArrayOutput) } +func (i NonResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -3219,6 +3688,12 @@ func (o NonResourcePolicyRulePatchOutput) ToNonResourcePolicyRulePatchOutputWith return o } +func (o NonResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -3249,6 +3724,12 @@ func (o NonResourcePolicyRulePatchArrayOutput) ToNonResourcePolicyRulePatchArray return o } +func (o NonResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRulePatch { return vs[0].([]NonResourcePolicyRulePatch)[vs[1].(int)] @@ -3298,6 +3779,12 @@ func (i PolicyRulesWithSubjectsArgs) ToPolicyRulesWithSubjectsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsOutput) } +func (i PolicyRulesWithSubjectsArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsArrayInput is an input type that accepts PolicyRulesWithSubjectsArray and PolicyRulesWithSubjectsArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsArrayInput` via: // @@ -3323,6 +3810,12 @@ func (i PolicyRulesWithSubjectsArray) ToPolicyRulesWithSubjectsArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsArrayOutput) } +func (i PolicyRulesWithSubjectsArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsOutput struct{ *pulumi.OutputState } @@ -3338,6 +3831,12 @@ func (o PolicyRulesWithSubjectsOutput) ToPolicyRulesWithSubjectsOutputWithContex return o } +func (o PolicyRulesWithSubjectsOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsOutput) NonResourceRules() NonResourcePolicyRuleArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjects) []NonResourcePolicyRule { return v.NonResourceRules }).(NonResourcePolicyRuleArrayOutput) @@ -3367,6 +3866,12 @@ func (o PolicyRulesWithSubjectsArrayOutput) ToPolicyRulesWithSubjectsArrayOutput return o } +func (o PolicyRulesWithSubjectsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjects { return vs[0].([]PolicyRulesWithSubjects)[vs[1].(int)] @@ -3416,6 +3921,12 @@ func (i PolicyRulesWithSubjectsPatchArgs) ToPolicyRulesWithSubjectsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchOutput) } +func (i PolicyRulesWithSubjectsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsPatchArrayInput is an input type that accepts PolicyRulesWithSubjectsPatchArray and PolicyRulesWithSubjectsPatchArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsPatchArrayInput` via: // @@ -3441,6 +3952,12 @@ func (i PolicyRulesWithSubjectsPatchArray) ToPolicyRulesWithSubjectsPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchArrayOutput) } +func (i PolicyRulesWithSubjectsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsPatchOutput struct{ *pulumi.OutputState } @@ -3456,6 +3973,12 @@ func (o PolicyRulesWithSubjectsPatchOutput) ToPolicyRulesWithSubjectsPatchOutput return o } +func (o PolicyRulesWithSubjectsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsPatchOutput) NonResourceRules() NonResourcePolicyRulePatchArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjectsPatch) []NonResourcePolicyRulePatch { return v.NonResourceRules }).(NonResourcePolicyRulePatchArrayOutput) @@ -3485,6 +4008,12 @@ func (o PolicyRulesWithSubjectsPatchArrayOutput) ToPolicyRulesWithSubjectsPatchA return o } +func (o PolicyRulesWithSubjectsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsPatchArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjectsPatch { return vs[0].([]PolicyRulesWithSubjectsPatch)[vs[1].(int)] @@ -3542,6 +4071,12 @@ func (i PriorityLevelConfigurationTypeArgs) ToPriorityLevelConfigurationTypeOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeOutput) } +func (i PriorityLevelConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationTypeArrayInput is an input type that accepts PriorityLevelConfigurationTypeArray and PriorityLevelConfigurationTypeArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationTypeArrayInput` via: // @@ -3567,6 +4102,12 @@ func (i PriorityLevelConfigurationTypeArray) ToPriorityLevelConfigurationTypeArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeArrayOutput) } +func (i PriorityLevelConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -3582,6 +4123,12 @@ func (o PriorityLevelConfigurationTypeOutput) ToPriorityLevelConfigurationTypeOu return o } +func (o PriorityLevelConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3621,6 +4168,12 @@ func (o PriorityLevelConfigurationTypeArrayOutput) ToPriorityLevelConfigurationT return o } +func (o PriorityLevelConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationTypeArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationType { return vs[0].([]PriorityLevelConfigurationType)[vs[1].(int)] @@ -3678,6 +4231,12 @@ func (i PriorityLevelConfigurationConditionArgs) ToPriorityLevelConfigurationCon return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionOutput) } +func (i PriorityLevelConfigurationConditionArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionArrayInput is an input type that accepts PriorityLevelConfigurationConditionArray and PriorityLevelConfigurationConditionArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionArrayInput` via: // @@ -3703,6 +4262,12 @@ func (i PriorityLevelConfigurationConditionArray) ToPriorityLevelConfigurationCo return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionArrayOutput) } +func (i PriorityLevelConfigurationConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionOutput struct{ *pulumi.OutputState } @@ -3718,6 +4283,12 @@ func (o PriorityLevelConfigurationConditionOutput) ToPriorityLevelConfigurationC return o } +func (o PriorityLevelConfigurationConditionOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3757,6 +4328,12 @@ func (o PriorityLevelConfigurationConditionArrayOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationCondition { return vs[0].([]PriorityLevelConfigurationCondition)[vs[1].(int)] @@ -3814,6 +4391,12 @@ func (i PriorityLevelConfigurationConditionPatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchOutput) } +func (i PriorityLevelConfigurationConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionPatchArrayInput is an input type that accepts PriorityLevelConfigurationConditionPatchArray and PriorityLevelConfigurationConditionPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionPatchArrayInput` via: // @@ -3839,6 +4422,12 @@ func (i PriorityLevelConfigurationConditionPatchArray) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchArrayOutput) } +func (i PriorityLevelConfigurationConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionPatchOutput struct{ *pulumi.OutputState } @@ -3854,6 +4443,12 @@ func (o PriorityLevelConfigurationConditionPatchOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3893,6 +4488,12 @@ func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToPriorityLevelConf return o } +func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationConditionPatch { return vs[0].([]PriorityLevelConfigurationConditionPatch)[vs[1].(int)] @@ -3946,6 +4547,12 @@ func (i PriorityLevelConfigurationListTypeArgs) ToPriorityLevelConfigurationList return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListTypeOutput) } +func (i PriorityLevelConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: i.ToPriorityLevelConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. type PriorityLevelConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -3961,6 +4568,12 @@ func (o PriorityLevelConfigurationListTypeOutput) ToPriorityLevelConfigurationLi return o } +func (o PriorityLevelConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4032,6 +4645,12 @@ func (i PriorityLevelConfigurationPatchTypeArgs) ToPriorityLevelConfigurationPat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchTypeOutput) } +func (i PriorityLevelConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: i.ToPriorityLevelConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -4047,6 +4666,12 @@ func (o PriorityLevelConfigurationPatchTypeOutput) ToPriorityLevelConfigurationP return o } +func (o PriorityLevelConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4107,6 +4732,12 @@ func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationRef return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferenceOutput) } +func (i PriorityLevelConfigurationReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferenceOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationReferencePtrOutput() PriorityLevelConfigurationReferencePtrOutput { return i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(context.Background()) } @@ -4148,6 +4779,12 @@ func (i *priorityLevelConfigurationReferencePtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePtrOutput) } +func (i *priorityLevelConfigurationReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferenceOutput struct{ *pulumi.OutputState } @@ -4173,6 +4810,12 @@ func (o PriorityLevelConfigurationReferenceOutput) ToPriorityLevelConfigurationR }).(PriorityLevelConfigurationReferencePtrOutput) } +func (o PriorityLevelConfigurationReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PriorityLevelConfigurationReference) string { return v.Name }).(pulumi.StringOutput) @@ -4192,6 +4835,12 @@ func (o PriorityLevelConfigurationReferencePtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePtrOutput) Elem() PriorityLevelConfigurationReferenceOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReference) PriorityLevelConfigurationReference { if v != nil { @@ -4247,6 +4896,12 @@ func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchOutput) } +func (i PriorityLevelConfigurationReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurationReferencePatchPtrOutput() PriorityLevelConfigurationReferencePatchPtrOutput { return i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(context.Background()) } @@ -4288,6 +4943,12 @@ func (i *priorityLevelConfigurationReferencePatchPtrType) ToPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (i *priorityLevelConfigurationReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferencePatchOutput struct{ *pulumi.OutputState } @@ -4313,6 +4974,12 @@ func (o PriorityLevelConfigurationReferencePatchOutput) ToPriorityLevelConfigura }).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (o PriorityLevelConfigurationReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -4332,6 +4999,12 @@ func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToPriorityLevelConfig return o } +func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePatchPtrOutput) Elem() PriorityLevelConfigurationReferencePatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReferencePatch) PriorityLevelConfigurationReferencePatch { if v != nil { @@ -4395,6 +5068,12 @@ func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecOutput) } +func (i PriorityLevelConfigurationSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecPtrOutput() PriorityLevelConfigurationSpecPtrOutput { return i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(context.Background()) } @@ -4436,6 +5115,12 @@ func (i *priorityLevelConfigurationSpecPtrType) ToPriorityLevelConfigurationSpec return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPtrOutput) } +func (i *priorityLevelConfigurationSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecOutput struct{ *pulumi.OutputState } @@ -4461,6 +5146,12 @@ func (o PriorityLevelConfigurationSpecOutput) ToPriorityLevelConfigurationSpecPt }).(PriorityLevelConfigurationSpecPtrOutput) } +func (o PriorityLevelConfigurationSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + // `exempt` specifies how requests are handled for an exempt priority level. This field MUST be empty if `type` is `"Limited"`. This field MAY be non-empty if `type` is `"Exempt"`. If empty and `type` is `"Exempt"` then the default values for `ExemptPriorityLevelConfiguration` apply. func (o PriorityLevelConfigurationSpecOutput) Exempt() ExemptPriorityLevelConfigurationPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpec) *ExemptPriorityLevelConfiguration { return v.Exempt }).(ExemptPriorityLevelConfigurationPtrOutput) @@ -4490,6 +5181,12 @@ func (o PriorityLevelConfigurationSpecPtrOutput) ToPriorityLevelConfigurationSpe return o } +func (o PriorityLevelConfigurationSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPtrOutput) Elem() PriorityLevelConfigurationSpecOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpec) PriorityLevelConfigurationSpec { if v != nil { @@ -4573,6 +5270,12 @@ func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpe return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchOutput) } +func (i PriorityLevelConfigurationSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpecPatchPtrOutput() PriorityLevelConfigurationSpecPatchPtrOutput { return i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(context.Background()) } @@ -4614,6 +5317,12 @@ func (i *priorityLevelConfigurationSpecPatchPtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (i *priorityLevelConfigurationSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecPatchOutput struct{ *pulumi.OutputState } @@ -4639,6 +5348,12 @@ func (o PriorityLevelConfigurationSpecPatchOutput) ToPriorityLevelConfigurationS }).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (o PriorityLevelConfigurationSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + // `exempt` specifies how requests are handled for an exempt priority level. This field MUST be empty if `type` is `"Limited"`. This field MAY be non-empty if `type` is `"Exempt"`. If empty and `type` is `"Exempt"` then the default values for `ExemptPriorityLevelConfiguration` apply. func (o PriorityLevelConfigurationSpecPatchOutput) Exempt() ExemptPriorityLevelConfigurationPatchPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpecPatch) *ExemptPriorityLevelConfigurationPatch { return v.Exempt }).(ExemptPriorityLevelConfigurationPatchPtrOutput) @@ -4668,6 +5383,12 @@ func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPatchPtrOutput) Elem() PriorityLevelConfigurationSpecPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpecPatch) PriorityLevelConfigurationSpecPatch { if v != nil { @@ -4743,6 +5464,12 @@ func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatus return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusOutput) } +func (i PriorityLevelConfigurationStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatusPtrOutput() PriorityLevelConfigurationStatusPtrOutput { return i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(context.Background()) } @@ -4784,6 +5511,12 @@ func (i *priorityLevelConfigurationStatusPtrType) ToPriorityLevelConfigurationSt return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPtrOutput) } +func (i *priorityLevelConfigurationStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusOutput struct{ *pulumi.OutputState } @@ -4809,6 +5542,12 @@ func (o PriorityLevelConfigurationStatusOutput) ToPriorityLevelConfigurationStat }).(PriorityLevelConfigurationStatusPtrOutput) } +func (o PriorityLevelConfigurationStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusOutput) Conditions() PriorityLevelConfigurationConditionArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatus) []PriorityLevelConfigurationCondition { return v.Conditions }).(PriorityLevelConfigurationConditionArrayOutput) @@ -4828,6 +5567,12 @@ func (o PriorityLevelConfigurationStatusPtrOutput) ToPriorityLevelConfigurationS return o } +func (o PriorityLevelConfigurationStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPtrOutput) Elem() PriorityLevelConfigurationStatusOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatus) PriorityLevelConfigurationStatus { if v != nil { @@ -4883,6 +5628,12 @@ func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationS return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchOutput) } +func (i PriorityLevelConfigurationStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationStatusPatchPtrOutput() PriorityLevelConfigurationStatusPatchPtrOutput { return i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(context.Background()) } @@ -4924,6 +5675,12 @@ func (i *priorityLevelConfigurationStatusPatchPtrType) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (i *priorityLevelConfigurationStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusPatchOutput struct{ *pulumi.OutputState } @@ -4949,6 +5706,12 @@ func (o PriorityLevelConfigurationStatusPatchOutput) ToPriorityLevelConfiguratio }).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (o PriorityLevelConfigurationStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusPatchOutput) Conditions() PriorityLevelConfigurationConditionPatchArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatusPatch) []PriorityLevelConfigurationConditionPatch { @@ -4970,6 +5733,12 @@ func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPatchPtrOutput) Elem() PriorityLevelConfigurationStatusPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatusPatch) PriorityLevelConfigurationStatusPatch { if v != nil { @@ -5033,6 +5802,12 @@ func (i QueuingConfigurationArgs) ToQueuingConfigurationOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationOutput) } +func (i QueuingConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationArgs) ToQueuingConfigurationPtrOutput() QueuingConfigurationPtrOutput { return i.ToQueuingConfigurationPtrOutputWithContext(context.Background()) } @@ -5074,6 +5849,12 @@ func (i *queuingConfigurationPtrType) ToQueuingConfigurationPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPtrOutput) } +func (i *queuingConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationOutput struct{ *pulumi.OutputState } @@ -5099,6 +5880,12 @@ func (o QueuingConfigurationOutput) ToQueuingConfigurationPtrOutputWithContext(c }).(QueuingConfigurationPtrOutput) } +func (o QueuingConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfiguration) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -5128,6 +5915,12 @@ func (o QueuingConfigurationPtrOutput) ToQueuingConfigurationPtrOutputWithContex return o } +func (o QueuingConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPtrOutput) Elem() QueuingConfigurationOutput { return o.ApplyT(func(v *QueuingConfiguration) QueuingConfiguration { if v != nil { @@ -5211,6 +6004,12 @@ func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchOutput) } +func (i QueuingConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchPtrOutput() QueuingConfigurationPatchPtrOutput { return i.ToQueuingConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -5252,6 +6051,12 @@ func (i *queuingConfigurationPatchPtrType) ToQueuingConfigurationPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchPtrOutput) } +func (i *queuingConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationPatchOutput struct{ *pulumi.OutputState } @@ -5277,6 +6082,12 @@ func (o QueuingConfigurationPatchOutput) ToQueuingConfigurationPatchPtrOutputWit }).(QueuingConfigurationPatchPtrOutput) } +func (o QueuingConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationPatchOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfigurationPatch) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -5306,6 +6117,12 @@ func (o QueuingConfigurationPatchPtrOutput) ToQueuingConfigurationPatchPtrOutput return o } +func (o QueuingConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPatchPtrOutput) Elem() QueuingConfigurationPatchOutput { return o.ApplyT(func(v *QueuingConfigurationPatch) QueuingConfigurationPatch { if v != nil { @@ -5397,6 +6214,12 @@ func (i ResourcePolicyRuleArgs) ToResourcePolicyRuleOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleOutput) } +func (i ResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRuleArrayInput is an input type that accepts ResourcePolicyRuleArray and ResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRuleArrayInput` via: // @@ -5422,6 +6245,12 @@ func (i ResourcePolicyRuleArray) ToResourcePolicyRuleArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleArrayOutput) } +func (i ResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==""`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace. type ResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -5437,6 +6266,12 @@ func (o ResourcePolicyRuleOutput) ToResourcePolicyRuleOutputWithContext(ctx cont return o } +func (o ResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -5476,6 +6311,12 @@ func (o ResourcePolicyRuleArrayOutput) ToResourcePolicyRuleArrayOutputWithContex return o } +func (o ResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRule { return vs[0].([]ResourcePolicyRule)[vs[1].(int)] @@ -5533,6 +6374,12 @@ func (i ResourcePolicyRulePatchArgs) ToResourcePolicyRulePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchOutput) } +func (i ResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRulePatchArrayInput is an input type that accepts ResourcePolicyRulePatchArray and ResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRulePatchArrayInput` via: // @@ -5558,6 +6405,12 @@ func (i ResourcePolicyRulePatchArray) ToResourcePolicyRulePatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchArrayOutput) } +func (i ResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==""`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace. type ResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -5573,6 +6426,12 @@ func (o ResourcePolicyRulePatchOutput) ToResourcePolicyRulePatchOutputWithContex return o } +func (o ResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -5612,6 +6471,12 @@ func (o ResourcePolicyRulePatchArrayOutput) ToResourcePolicyRulePatchArrayOutput return o } +func (o ResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRulePatch { return vs[0].([]ResourcePolicyRulePatch)[vs[1].(int)] @@ -5657,6 +6522,12 @@ func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectOutput) } +func (i ServiceAccountSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectPtrOutput() ServiceAccountSubjectPtrOutput { return i.ToServiceAccountSubjectPtrOutputWithContext(context.Background()) } @@ -5698,6 +6569,12 @@ func (i *serviceAccountSubjectPtrType) ToServiceAccountSubjectPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPtrOutput) } +func (i *serviceAccountSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectOutput struct{ *pulumi.OutputState } @@ -5723,6 +6600,12 @@ func (o ServiceAccountSubjectOutput) ToServiceAccountSubjectPtrOutputWithContext }).(ServiceAccountSubjectPtrOutput) } +func (o ServiceAccountSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceAccountSubject) string { return v.Name }).(pulumi.StringOutput) @@ -5747,6 +6630,12 @@ func (o ServiceAccountSubjectPtrOutput) ToServiceAccountSubjectPtrOutputWithCont return o } +func (o ServiceAccountSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPtrOutput) Elem() ServiceAccountSubjectOutput { return o.ApplyT(func(v *ServiceAccountSubject) ServiceAccountSubject { if v != nil { @@ -5816,6 +6705,12 @@ func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchOutput) } +func (i ServiceAccountSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchPtrOutput() ServiceAccountSubjectPatchPtrOutput { return i.ToServiceAccountSubjectPatchPtrOutputWithContext(context.Background()) } @@ -5857,6 +6752,12 @@ func (i *serviceAccountSubjectPatchPtrType) ToServiceAccountSubjectPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchPtrOutput) } +func (i *serviceAccountSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectPatchOutput struct{ *pulumi.OutputState } @@ -5882,6 +6783,12 @@ func (o ServiceAccountSubjectPatchOutput) ToServiceAccountSubjectPatchPtrOutputW }).(ServiceAccountSubjectPatchPtrOutput) } +func (o ServiceAccountSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5906,6 +6813,12 @@ func (o ServiceAccountSubjectPatchPtrOutput) ToServiceAccountSubjectPatchPtrOutp return o } +func (o ServiceAccountSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPatchPtrOutput) Elem() ServiceAccountSubjectPatchOutput { return o.ApplyT(func(v *ServiceAccountSubjectPatch) ServiceAccountSubjectPatch { if v != nil { @@ -5983,6 +6896,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -6008,6 +6927,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectOutput struct{ *pulumi.OutputState } @@ -6023,6 +6948,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + // `group` matches based on user group name. func (o SubjectOutput) Group() GroupSubjectPtrOutput { return o.ApplyT(func(v Subject) *GroupSubject { return v.Group }).(GroupSubjectPtrOutput) @@ -6057,6 +6988,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -6110,6 +7047,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -6135,6 +7078,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -6150,6 +7099,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + // `group` matches based on user group name. func (o SubjectPatchOutput) Group() GroupSubjectPatchPtrOutput { return o.ApplyT(func(v SubjectPatch) *GroupSubjectPatch { return v.Group }).(GroupSubjectPatchPtrOutput) @@ -6184,6 +7139,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] @@ -6225,6 +7186,12 @@ func (i UserSubjectArgs) ToUserSubjectOutputWithContext(ctx context.Context) Use return pulumi.ToOutputWithContext(ctx, i).(UserSubjectOutput) } +func (i UserSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: i.ToUserSubjectOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectArgs) ToUserSubjectPtrOutput() UserSubjectPtrOutput { return i.ToUserSubjectPtrOutputWithContext(context.Background()) } @@ -6266,6 +7233,12 @@ func (i *userSubjectPtrType) ToUserSubjectPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPtrOutput) } +func (i *userSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: i.ToUserSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectOutput struct{ *pulumi.OutputState } @@ -6291,6 +7264,12 @@ func (o UserSubjectOutput) ToUserSubjectPtrOutputWithContext(ctx context.Context }).(UserSubjectPtrOutput) } +func (o UserSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v UserSubject) string { return v.Name }).(pulumi.StringOutput) @@ -6310,6 +7289,12 @@ func (o UserSubjectPtrOutput) ToUserSubjectPtrOutputWithContext(ctx context.Cont return o } +func (o UserSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPtrOutput) Elem() UserSubjectOutput { return o.ApplyT(func(v *UserSubject) UserSubject { if v != nil { @@ -6365,6 +7350,12 @@ func (i UserSubjectPatchArgs) ToUserSubjectPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchOutput) } +func (i UserSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectPatchArgs) ToUserSubjectPatchPtrOutput() UserSubjectPatchPtrOutput { return i.ToUserSubjectPatchPtrOutputWithContext(context.Background()) } @@ -6406,6 +7397,12 @@ func (i *userSubjectPatchPtrType) ToUserSubjectPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchPtrOutput) } +func (i *userSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectPatchOutput struct{ *pulumi.OutputState } @@ -6431,6 +7428,12 @@ func (o UserSubjectPatchOutput) ToUserSubjectPatchPtrOutputWithContext(ctx conte }).(UserSubjectPatchPtrOutput) } +func (o UserSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v UserSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -6450,6 +7453,12 @@ func (o UserSubjectPatchPtrOutput) ToUserSubjectPatchPtrOutputWithContext(ctx co return o } +func (o UserSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPatchPtrOutput) Elem() UserSubjectPatchOutput { return o.ApplyT(func(v *UserSubjectPatch) UserSubjectPatch { if v != nil { diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchema.go b/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchema.go index 7bc0d5ddf4..338d4de239 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchema.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchema.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". @@ -127,6 +128,12 @@ func (i *FlowSchema) ToFlowSchemaOutputWithContext(ctx context.Context) FlowSche return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaOutput) } +func (i *FlowSchema) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: i.ToFlowSchemaOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaArrayInput is an input type that accepts FlowSchemaArray and FlowSchemaArrayOutput values. // You can construct a concrete instance of `FlowSchemaArrayInput` via: // @@ -152,6 +159,12 @@ func (i FlowSchemaArray) ToFlowSchemaArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaArrayOutput) } +func (i FlowSchemaArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: i.ToFlowSchemaArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaMapInput is an input type that accepts FlowSchemaMap and FlowSchemaMapOutput values. // You can construct a concrete instance of `FlowSchemaMapInput` via: // @@ -177,6 +190,12 @@ func (i FlowSchemaMap) ToFlowSchemaMapOutputWithContext(ctx context.Context) Flo return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaMapOutput) } +func (i FlowSchemaMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: i.ToFlowSchemaMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaOutput struct{ *pulumi.OutputState } func (FlowSchemaOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o FlowSchemaOutput) ToFlowSchemaOutputWithContext(ctx context.Context) Flo return o } +func (o FlowSchemaOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchema] { + return pulumix.Output[*FlowSchema]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchema) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o FlowSchemaArrayOutput) ToFlowSchemaArrayOutputWithContext(ctx context.Co return o } +func (o FlowSchemaArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchema] { + return pulumix.Output[[]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaArrayOutput) Index(i pulumi.IntInput) FlowSchemaOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].([]*FlowSchema)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o FlowSchemaMapOutput) ToFlowSchemaMapOutputWithContext(ctx context.Contex return o } +func (o FlowSchemaMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchema] { + return pulumix.Output[map[string]*FlowSchema]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchema { return vs[0].(map[string]*FlowSchema)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaList.go b/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaList.go index bce78bbd62..fadf9032c2 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaList.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // FlowSchemaList is a list of FlowSchema objects. @@ -117,6 +118,12 @@ func (i *FlowSchemaList) ToFlowSchemaListOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListOutput) } +func (i *FlowSchemaList) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListArrayInput is an input type that accepts FlowSchemaListArray and FlowSchemaListArrayOutput values. // You can construct a concrete instance of `FlowSchemaListArrayInput` via: // @@ -142,6 +149,12 @@ func (i FlowSchemaListArray) ToFlowSchemaListArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListArrayOutput) } +func (i FlowSchemaListArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaListMapInput is an input type that accepts FlowSchemaListMap and FlowSchemaListMapOutput values. // You can construct a concrete instance of `FlowSchemaListMapInput` via: // @@ -167,6 +180,12 @@ func (i FlowSchemaListMap) ToFlowSchemaListMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListMapOutput) } +func (i FlowSchemaListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: i.ToFlowSchemaListMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaListOutput struct{ *pulumi.OutputState } func (FlowSchemaListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o FlowSchemaListOutput) ToFlowSchemaListOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaListOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaList] { + return pulumix.Output[*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *FlowSchemaList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o FlowSchemaListArrayOutput) ToFlowSchemaListArrayOutputWithContext(ctx co return o } +func (o FlowSchemaListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaList] { + return pulumix.Output[[]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListArrayOutput) Index(i pulumi.IntInput) FlowSchemaListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].([]*FlowSchemaList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o FlowSchemaListMapOutput) ToFlowSchemaListMapOutputWithContext(ctx contex return o } +func (o FlowSchemaListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaList] { + return pulumix.Output[map[string]*FlowSchemaList]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaListMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaList { return vs[0].(map[string]*FlowSchemaList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaPatch.go b/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaPatch.go index e3767b2439..ae3d977c43 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/flowSchemaPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *FlowSchemaPatch) ToFlowSchemaPatchOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchOutput) } +func (i *FlowSchemaPatch) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchArrayInput is an input type that accepts FlowSchemaPatchArray and FlowSchemaPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i FlowSchemaPatchArray) ToFlowSchemaPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchArrayOutput) } +func (i FlowSchemaPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaPatchMapInput is an input type that accepts FlowSchemaPatchMap and FlowSchemaPatchMapOutput values. // You can construct a concrete instance of `FlowSchemaPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i FlowSchemaPatchMap) ToFlowSchemaPatchMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchMapOutput) } +func (i FlowSchemaPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: i.ToFlowSchemaPatchMapOutputWithContext(ctx).OutputState, + } +} + type FlowSchemaPatchOutput struct{ *pulumi.OutputState } func (FlowSchemaPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o FlowSchemaPatchOutput) ToFlowSchemaPatchOutputWithContext(ctx context.Co return o } +func (o FlowSchemaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaPatch] { + return pulumix.Output[*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *FlowSchemaPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -236,6 +261,12 @@ func (o FlowSchemaPatchArrayOutput) ToFlowSchemaPatchArrayOutputWithContext(ctx return o } +func (o FlowSchemaPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*FlowSchemaPatch] { + return pulumix.Output[[]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].([]*FlowSchemaPatch)[vs[1].(int)] @@ -256,6 +287,12 @@ func (o FlowSchemaPatchMapOutput) ToFlowSchemaPatchMapOutputWithContext(ctx cont return o } +func (o FlowSchemaPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*FlowSchemaPatch] { + return pulumix.Output[map[string]*FlowSchemaPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaPatchMapOutput) MapIndex(k pulumi.StringInput) FlowSchemaPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *FlowSchemaPatch { return vs[0].(map[string]*FlowSchemaPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfiguration.go b/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfiguration.go index b07d92be29..805d1450b3 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfiguration.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfiguration.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfiguration represents the configuration of a priority level. @@ -127,6 +128,12 @@ func (i *PriorityLevelConfiguration) ToPriorityLevelConfigurationOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationOutput) } +func (i *PriorityLevelConfiguration) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationArrayInput is an input type that accepts PriorityLevelConfigurationArray and PriorityLevelConfigurationArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationArrayInput` via: // @@ -152,6 +159,12 @@ func (i PriorityLevelConfigurationArray) ToPriorityLevelConfigurationArrayOutput return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationArrayOutput) } +func (i PriorityLevelConfigurationArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationMapInput is an input type that accepts PriorityLevelConfigurationMap and PriorityLevelConfigurationMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationMapInput` via: // @@ -177,6 +190,12 @@ func (i PriorityLevelConfigurationMap) ToPriorityLevelConfigurationMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationMapOutput) } +func (i PriorityLevelConfigurationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: i.ToPriorityLevelConfigurationMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o PriorityLevelConfigurationOutput) ToPriorityLevelConfigurationOutputWith return o } +func (o PriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfiguration] { + return pulumix.Output[*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfiguration) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o PriorityLevelConfigurationArrayOutput) ToPriorityLevelConfigurationArray return o } +func (o PriorityLevelConfigurationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfiguration] { + return pulumix.Output[[]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].([]*PriorityLevelConfiguration)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o PriorityLevelConfigurationMapOutput) ToPriorityLevelConfigurationMapOutp return o } +func (o PriorityLevelConfigurationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfiguration] { + return pulumix.Output[map[string]*PriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfiguration { return vs[0].(map[string]*PriorityLevelConfiguration)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationList.go b/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationList.go index 45368e6e2f..5c78864d9f 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationList.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. @@ -117,6 +118,12 @@ func (i *PriorityLevelConfigurationList) ToPriorityLevelConfigurationListOutputW return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListOutput) } +func (i *PriorityLevelConfigurationList) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListArrayInput is an input type that accepts PriorityLevelConfigurationListArray and PriorityLevelConfigurationListArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityLevelConfigurationListArray) ToPriorityLevelConfigurationListArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListArrayOutput) } +func (i PriorityLevelConfigurationListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationListMapInput is an input type that accepts PriorityLevelConfigurationListMap and PriorityLevelConfigurationListMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityLevelConfigurationListMap) ToPriorityLevelConfigurationListMapOu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListMapOutput) } +func (i PriorityLevelConfigurationListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: i.ToPriorityLevelConfigurationListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationListOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityLevelConfigurationListOutput) ToPriorityLevelConfigurationListOu return o } +func (o PriorityLevelConfigurationListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationList] { + return pulumix.Output[*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityLevelConfigurationList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityLevelConfigurationListArrayOutput) ToPriorityLevelConfigurationL return o } +func (o PriorityLevelConfigurationListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationList] { + return pulumix.Output[[]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].([]*PriorityLevelConfigurationList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityLevelConfigurationListMapOutput) ToPriorityLevelConfigurationLis return o } +func (o PriorityLevelConfigurationListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationList] { + return pulumix.Output[map[string]*PriorityLevelConfigurationList]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationListMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationList { return vs[0].(map[string]*PriorityLevelConfigurationList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationPatch.go b/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationPatch.go index cfd77ead84..a09285bbed 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationPatch.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/priorityLevelConfigurationPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -133,6 +134,12 @@ func (i *PriorityLevelConfigurationPatch) ToPriorityLevelConfigurationPatchOutpu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchOutput) } +func (i *PriorityLevelConfigurationPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchArrayInput is an input type that accepts PriorityLevelConfigurationPatchArray and PriorityLevelConfigurationPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchArrayInput` via: // @@ -158,6 +165,12 @@ func (i PriorityLevelConfigurationPatchArray) ToPriorityLevelConfigurationPatchA return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchArrayOutput) } +func (i PriorityLevelConfigurationPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationPatchMapInput is an input type that accepts PriorityLevelConfigurationPatchMap and PriorityLevelConfigurationPatchMapOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationPatchMapInput` via: // @@ -183,6 +196,12 @@ func (i PriorityLevelConfigurationPatchMap) ToPriorityLevelConfigurationPatchMap return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchMapOutput) } +func (i PriorityLevelConfigurationPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: i.ToPriorityLevelConfigurationPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityLevelConfigurationPatchOutput struct{ *pulumi.OutputState } func (PriorityLevelConfigurationPatchOutput) ElementType() reflect.Type { @@ -197,6 +216,12 @@ func (o PriorityLevelConfigurationPatchOutput) ToPriorityLevelConfigurationPatch return o } +func (o PriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationPatch] { + return pulumix.Output[*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityLevelConfigurationPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -238,6 +263,12 @@ func (o PriorityLevelConfigurationPatchArrayOutput) ToPriorityLevelConfiguration return o } +func (o PriorityLevelConfigurationPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityLevelConfigurationPatch] { + return pulumix.Output[[]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].([]*PriorityLevelConfigurationPatch)[vs[1].(int)] @@ -258,6 +289,12 @@ func (o PriorityLevelConfigurationPatchMapOutput) ToPriorityLevelConfigurationPa return o } +func (o PriorityLevelConfigurationPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityLevelConfigurationPatch] { + return pulumix.Output[map[string]*PriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityLevelConfigurationPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityLevelConfigurationPatch { return vs[0].(map[string]*PriorityLevelConfigurationPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/flowcontrol/v1beta3/pulumiTypes.go b/sdk/go/kubernetes/flowcontrol/v1beta3/pulumiTypes.go index 5675dfc2d4..ab9d000235 100644 --- a/sdk/go/kubernetes/flowcontrol/v1beta3/pulumiTypes.go +++ b/sdk/go/kubernetes/flowcontrol/v1beta3/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -65,6 +66,12 @@ func (i ExemptPriorityLevelConfigurationArgs) ToExemptPriorityLevelConfiguration return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationOutput) } +func (i ExemptPriorityLevelConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfiguration] { + return pulumix.Output[ExemptPriorityLevelConfiguration]{ + OutputState: i.ToExemptPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i ExemptPriorityLevelConfigurationArgs) ToExemptPriorityLevelConfigurationPtrOutput() ExemptPriorityLevelConfigurationPtrOutput { return i.ToExemptPriorityLevelConfigurationPtrOutputWithContext(context.Background()) } @@ -106,6 +113,12 @@ func (i *exemptPriorityLevelConfigurationPtrType) ToExemptPriorityLevelConfigura return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationPtrOutput) } +func (i *exemptPriorityLevelConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfiguration] { + return pulumix.Output[*ExemptPriorityLevelConfiguration]{ + OutputState: i.ToExemptPriorityLevelConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // ExemptPriorityLevelConfiguration describes the configurable aspects of the handling of exempt requests. In the mandatory exempt configuration object the values in the fields here can be modified by authorized users, unlike the rest of the `spec`. type ExemptPriorityLevelConfigurationOutput struct{ *pulumi.OutputState } @@ -131,6 +144,12 @@ func (o ExemptPriorityLevelConfigurationOutput) ToExemptPriorityLevelConfigurati }).(ExemptPriorityLevelConfigurationPtrOutput) } +func (o ExemptPriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfiguration] { + return pulumix.Output[ExemptPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // `lendablePercent` prescribes the fraction of the level's NominalCL that can be borrowed by other priority levels. This value of this field must be between 0 and 100, inclusive, and it defaults to 0. The number of seats that other levels can borrow from this level, known as this level's LendableConcurrencyLimit (LendableCL), is defined as follows. // // LendableCL(i) = round( NominalCL(i) * lendablePercent(i)/100.0 ) @@ -161,6 +180,12 @@ func (o ExemptPriorityLevelConfigurationPtrOutput) ToExemptPriorityLevelConfigur return o } +func (o ExemptPriorityLevelConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfiguration] { + return pulumix.Output[*ExemptPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o ExemptPriorityLevelConfigurationPtrOutput) Elem() ExemptPriorityLevelConfigurationOutput { return o.ApplyT(func(v *ExemptPriorityLevelConfiguration) ExemptPriorityLevelConfiguration { if v != nil { @@ -248,6 +273,12 @@ func (i ExemptPriorityLevelConfigurationPatchArgs) ToExemptPriorityLevelConfigur return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationPatchOutput) } +func (i ExemptPriorityLevelConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[ExemptPriorityLevelConfigurationPatch]{ + OutputState: i.ToExemptPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i ExemptPriorityLevelConfigurationPatchArgs) ToExemptPriorityLevelConfigurationPatchPtrOutput() ExemptPriorityLevelConfigurationPatchPtrOutput { return i.ToExemptPriorityLevelConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -289,6 +320,12 @@ func (i *exemptPriorityLevelConfigurationPatchPtrType) ToExemptPriorityLevelConf return pulumi.ToOutputWithContext(ctx, i).(ExemptPriorityLevelConfigurationPatchPtrOutput) } +func (i *exemptPriorityLevelConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[*ExemptPriorityLevelConfigurationPatch]{ + OutputState: i.ToExemptPriorityLevelConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ExemptPriorityLevelConfiguration describes the configurable aspects of the handling of exempt requests. In the mandatory exempt configuration object the values in the fields here can be modified by authorized users, unlike the rest of the `spec`. type ExemptPriorityLevelConfigurationPatchOutput struct{ *pulumi.OutputState } @@ -314,6 +351,12 @@ func (o ExemptPriorityLevelConfigurationPatchOutput) ToExemptPriorityLevelConfig }).(ExemptPriorityLevelConfigurationPatchPtrOutput) } +func (o ExemptPriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[ExemptPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `lendablePercent` prescribes the fraction of the level's NominalCL that can be borrowed by other priority levels. This value of this field must be between 0 and 100, inclusive, and it defaults to 0. The number of seats that other levels can borrow from this level, known as this level's LendableConcurrencyLimit (LendableCL), is defined as follows. // // LendableCL(i) = round( NominalCL(i) * lendablePercent(i)/100.0 ) @@ -344,6 +387,12 @@ func (o ExemptPriorityLevelConfigurationPatchPtrOutput) ToExemptPriorityLevelCon return o } +func (o ExemptPriorityLevelConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ExemptPriorityLevelConfigurationPatch] { + return pulumix.Output[*ExemptPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o ExemptPriorityLevelConfigurationPatchPtrOutput) Elem() ExemptPriorityLevelConfigurationPatchOutput { return o.ApplyT(func(v *ExemptPriorityLevelConfigurationPatch) ExemptPriorityLevelConfigurationPatch { if v != nil { @@ -415,6 +464,12 @@ func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodOutput) } +func (i FlowDistinguisherMethodArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodArgs) ToFlowDistinguisherMethodPtrOutput() FlowDistinguisherMethodPtrOutput { return i.ToFlowDistinguisherMethodPtrOutputWithContext(context.Background()) } @@ -456,6 +511,12 @@ func (i *flowDistinguisherMethodPtrType) ToFlowDistinguisherMethodPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPtrOutput) } +func (i *flowDistinguisherMethodPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: i.ToFlowDistinguisherMethodPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodOutput struct{ *pulumi.OutputState } @@ -481,6 +542,12 @@ func (o FlowDistinguisherMethodOutput) ToFlowDistinguisherMethodPtrOutputWithCon }).(FlowDistinguisherMethodPtrOutput) } +func (o FlowDistinguisherMethodOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethod] { + return pulumix.Output[FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodOutput) Type() pulumi.StringOutput { return o.ApplyT(func(v FlowDistinguisherMethod) string { return v.Type }).(pulumi.StringOutput) @@ -500,6 +567,12 @@ func (o FlowDistinguisherMethodPtrOutput) ToFlowDistinguisherMethodPtrOutputWith return o } +func (o FlowDistinguisherMethodPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethod] { + return pulumix.Output[*FlowDistinguisherMethod]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPtrOutput) Elem() FlowDistinguisherMethodOutput { return o.ApplyT(func(v *FlowDistinguisherMethod) FlowDistinguisherMethod { if v != nil { @@ -555,6 +628,12 @@ func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchOutput) } +func (i FlowDistinguisherMethodPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowDistinguisherMethodPatchArgs) ToFlowDistinguisherMethodPatchPtrOutput() FlowDistinguisherMethodPatchPtrOutput { return i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(context.Background()) } @@ -596,6 +675,12 @@ func (i *flowDistinguisherMethodPatchPtrType) ToFlowDistinguisherMethodPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(FlowDistinguisherMethodPatchPtrOutput) } +func (i *flowDistinguisherMethodPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: i.ToFlowDistinguisherMethodPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowDistinguisherMethod specifies the method of a flow distinguisher. type FlowDistinguisherMethodPatchOutput struct{ *pulumi.OutputState } @@ -621,6 +706,12 @@ func (o FlowDistinguisherMethodPatchOutput) ToFlowDistinguisherMethodPatchPtrOut }).(FlowDistinguisherMethodPatchPtrOutput) } +func (o FlowDistinguisherMethodPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowDistinguisherMethodPatch] { + return pulumix.Output[FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + // `type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. func (o FlowDistinguisherMethodPatchOutput) Type() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowDistinguisherMethodPatch) *string { return v.Type }).(pulumi.StringPtrOutput) @@ -640,6 +731,12 @@ func (o FlowDistinguisherMethodPatchPtrOutput) ToFlowDistinguisherMethodPatchPtr return o } +func (o FlowDistinguisherMethodPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowDistinguisherMethodPatch] { + return pulumix.Output[*FlowDistinguisherMethodPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowDistinguisherMethodPatchPtrOutput) Elem() FlowDistinguisherMethodPatchOutput { return o.ApplyT(func(v *FlowDistinguisherMethodPatch) FlowDistinguisherMethodPatch { if v != nil { @@ -711,6 +808,12 @@ func (i FlowSchemaTypeArgs) ToFlowSchemaTypeOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeOutput) } +func (i FlowSchemaTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaTypeArrayInput is an input type that accepts FlowSchemaTypeArray and FlowSchemaTypeArrayOutput values. // You can construct a concrete instance of `FlowSchemaTypeArrayInput` via: // @@ -736,6 +839,12 @@ func (i FlowSchemaTypeArray) ToFlowSchemaTypeArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaTypeArrayOutput) } +func (i FlowSchemaTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: i.ToFlowSchemaTypeArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaTypeOutput struct{ *pulumi.OutputState } @@ -751,6 +860,12 @@ func (o FlowSchemaTypeOutput) ToFlowSchemaTypeOutputWithContext(ctx context.Cont return o } +func (o FlowSchemaTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaType] { + return pulumix.Output[FlowSchemaType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -790,6 +905,12 @@ func (o FlowSchemaTypeArrayOutput) ToFlowSchemaTypeArrayOutputWithContext(ctx co return o } +func (o FlowSchemaTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaType] { + return pulumix.Output[[]FlowSchemaType]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaTypeArrayOutput) Index(i pulumi.IntInput) FlowSchemaTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaType { return vs[0].([]FlowSchemaType)[vs[1].(int)] @@ -847,6 +968,12 @@ func (i FlowSchemaConditionArgs) ToFlowSchemaConditionOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionOutput) } +func (i FlowSchemaConditionArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionArrayInput is an input type that accepts FlowSchemaConditionArray and FlowSchemaConditionArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionArrayInput` via: // @@ -872,6 +999,12 @@ func (i FlowSchemaConditionArray) ToFlowSchemaConditionArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionArrayOutput) } +func (i FlowSchemaConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: i.ToFlowSchemaConditionArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionOutput struct{ *pulumi.OutputState } @@ -887,6 +1020,12 @@ func (o FlowSchemaConditionOutput) ToFlowSchemaConditionOutputWithContext(ctx co return o } +func (o FlowSchemaConditionOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaCondition] { + return pulumix.Output[FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -926,6 +1065,12 @@ func (o FlowSchemaConditionArrayOutput) ToFlowSchemaConditionArrayOutputWithCont return o } +func (o FlowSchemaConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaCondition] { + return pulumix.Output[[]FlowSchemaCondition]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaCondition { return vs[0].([]FlowSchemaCondition)[vs[1].(int)] @@ -983,6 +1128,12 @@ func (i FlowSchemaConditionPatchArgs) ToFlowSchemaConditionPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchOutput) } +func (i FlowSchemaConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaConditionPatchArrayInput is an input type that accepts FlowSchemaConditionPatchArray and FlowSchemaConditionPatchArrayOutput values. // You can construct a concrete instance of `FlowSchemaConditionPatchArrayInput` via: // @@ -1008,6 +1159,12 @@ func (i FlowSchemaConditionPatchArray) ToFlowSchemaConditionPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaConditionPatchArrayOutput) } +func (i FlowSchemaConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: i.ToFlowSchemaConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaCondition describes conditions for a FlowSchema. type FlowSchemaConditionPatchOutput struct{ *pulumi.OutputState } @@ -1023,6 +1180,12 @@ func (o FlowSchemaConditionPatchOutput) ToFlowSchemaConditionPatchOutputWithCont return o } +func (o FlowSchemaConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaConditionPatch] { + return pulumix.Output[FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o FlowSchemaConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -1062,6 +1225,12 @@ func (o FlowSchemaConditionPatchArrayOutput) ToFlowSchemaConditionPatchArrayOutp return o } +func (o FlowSchemaConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]FlowSchemaConditionPatch] { + return pulumix.Output[[]FlowSchemaConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaConditionPatchArrayOutput) Index(i pulumi.IntInput) FlowSchemaConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) FlowSchemaConditionPatch { return vs[0].([]FlowSchemaConditionPatch)[vs[1].(int)] @@ -1115,6 +1284,12 @@ func (i FlowSchemaListTypeArgs) ToFlowSchemaListTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaListTypeOutput) } +func (i FlowSchemaListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: i.ToFlowSchemaListTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaList is a list of FlowSchema objects. type FlowSchemaListTypeOutput struct{ *pulumi.OutputState } @@ -1130,6 +1305,12 @@ func (o FlowSchemaListTypeOutput) ToFlowSchemaListTypeOutputWithContext(ctx cont return o } +func (o FlowSchemaListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaListType] { + return pulumix.Output[FlowSchemaListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1201,6 +1382,12 @@ func (i FlowSchemaPatchTypeArgs) ToFlowSchemaPatchTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaPatchTypeOutput) } +func (i FlowSchemaPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: i.ToFlowSchemaPatchTypeOutputWithContext(ctx).OutputState, + } +} + // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". type FlowSchemaPatchTypeOutput struct{ *pulumi.OutputState } @@ -1216,6 +1403,12 @@ func (o FlowSchemaPatchTypeOutput) ToFlowSchemaPatchTypeOutputWithContext(ctx co return o } +func (o FlowSchemaPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaPatchType] { + return pulumix.Output[FlowSchemaPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o FlowSchemaPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v FlowSchemaPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1288,6 +1481,12 @@ func (i FlowSchemaSpecArgs) ToFlowSchemaSpecOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecOutput) } +func (i FlowSchemaSpecArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecArgs) ToFlowSchemaSpecPtrOutput() FlowSchemaSpecPtrOutput { return i.ToFlowSchemaSpecPtrOutputWithContext(context.Background()) } @@ -1329,6 +1528,12 @@ func (i *flowSchemaSpecPtrType) ToFlowSchemaSpecPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPtrOutput) } +func (i *flowSchemaSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: i.ToFlowSchemaSpecPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecOutput struct{ *pulumi.OutputState } @@ -1354,6 +1559,12 @@ func (o FlowSchemaSpecOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx context.C }).(FlowSchemaSpecPtrOutput) } +func (o FlowSchemaSpecOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpec] { + return pulumix.Output[FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecOutput) DistinguisherMethod() FlowDistinguisherMethodPtrOutput { return o.ApplyT(func(v FlowSchemaSpec) *FlowDistinguisherMethod { return v.DistinguisherMethod }).(FlowDistinguisherMethodPtrOutput) @@ -1388,6 +1599,12 @@ func (o FlowSchemaSpecPtrOutput) ToFlowSchemaSpecPtrOutputWithContext(ctx contex return o } +func (o FlowSchemaSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpec] { + return pulumix.Output[*FlowSchemaSpec]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPtrOutput) Elem() FlowSchemaSpecOutput { return o.ApplyT(func(v *FlowSchemaSpec) FlowSchemaSpec { if v != nil { @@ -1485,6 +1702,12 @@ func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchOutput) } +func (i FlowSchemaSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaSpecPatchArgs) ToFlowSchemaSpecPatchPtrOutput() FlowSchemaSpecPatchPtrOutput { return i.ToFlowSchemaSpecPatchPtrOutputWithContext(context.Background()) } @@ -1526,6 +1749,12 @@ func (i *flowSchemaSpecPatchPtrType) ToFlowSchemaSpecPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaSpecPatchPtrOutput) } +func (i *flowSchemaSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: i.ToFlowSchemaSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaSpec describes how the FlowSchema's specification looks like. type FlowSchemaSpecPatchOutput struct{ *pulumi.OutputState } @@ -1551,6 +1780,12 @@ func (o FlowSchemaSpecPatchOutput) ToFlowSchemaSpecPatchPtrOutputWithContext(ctx }).(FlowSchemaSpecPatchPtrOutput) } +func (o FlowSchemaSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaSpecPatch] { + return pulumix.Output[FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. func (o FlowSchemaSpecPatchOutput) DistinguisherMethod() FlowDistinguisherMethodPatchPtrOutput { return o.ApplyT(func(v FlowSchemaSpecPatch) *FlowDistinguisherMethodPatch { return v.DistinguisherMethod }).(FlowDistinguisherMethodPatchPtrOutput) @@ -1587,6 +1822,12 @@ func (o FlowSchemaSpecPatchPtrOutput) ToFlowSchemaSpecPatchPtrOutputWithContext( return o } +func (o FlowSchemaSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaSpecPatch] { + return pulumix.Output[*FlowSchemaSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaSpecPatchPtrOutput) Elem() FlowSchemaSpecPatchOutput { return o.ApplyT(func(v *FlowSchemaSpecPatch) FlowSchemaSpecPatch { if v != nil { @@ -1672,6 +1913,12 @@ func (i FlowSchemaStatusArgs) ToFlowSchemaStatusOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusOutput) } +func (i FlowSchemaStatusArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusArgs) ToFlowSchemaStatusPtrOutput() FlowSchemaStatusPtrOutput { return i.ToFlowSchemaStatusPtrOutputWithContext(context.Background()) } @@ -1713,6 +1960,12 @@ func (i *flowSchemaStatusPtrType) ToFlowSchemaStatusPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPtrOutput) } +func (i *flowSchemaStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: i.ToFlowSchemaStatusPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusOutput struct{ *pulumi.OutputState } @@ -1738,6 +1991,12 @@ func (o FlowSchemaStatusOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx conte }).(FlowSchemaStatusPtrOutput) } +func (o FlowSchemaStatusOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatus] { + return pulumix.Output[FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusOutput) Conditions() FlowSchemaConditionArrayOutput { return o.ApplyT(func(v FlowSchemaStatus) []FlowSchemaCondition { return v.Conditions }).(FlowSchemaConditionArrayOutput) @@ -1757,6 +2016,12 @@ func (o FlowSchemaStatusPtrOutput) ToFlowSchemaStatusPtrOutputWithContext(ctx co return o } +func (o FlowSchemaStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatus] { + return pulumix.Output[*FlowSchemaStatus]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPtrOutput) Elem() FlowSchemaStatusOutput { return o.ApplyT(func(v *FlowSchemaStatus) FlowSchemaStatus { if v != nil { @@ -1812,6 +2077,12 @@ func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchOutput) } +func (i FlowSchemaStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i FlowSchemaStatusPatchArgs) ToFlowSchemaStatusPatchPtrOutput() FlowSchemaStatusPatchPtrOutput { return i.ToFlowSchemaStatusPatchPtrOutputWithContext(context.Background()) } @@ -1853,6 +2124,12 @@ func (i *flowSchemaStatusPatchPtrType) ToFlowSchemaStatusPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(FlowSchemaStatusPatchPtrOutput) } +func (i *flowSchemaStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: i.ToFlowSchemaStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FlowSchemaStatus represents the current state of a FlowSchema. type FlowSchemaStatusPatchOutput struct{ *pulumi.OutputState } @@ -1878,6 +2155,12 @@ func (o FlowSchemaStatusPatchOutput) ToFlowSchemaStatusPatchPtrOutputWithContext }).(FlowSchemaStatusPatchPtrOutput) } +func (o FlowSchemaStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FlowSchemaStatusPatch] { + return pulumix.Output[FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is a list of the current states of FlowSchema. func (o FlowSchemaStatusPatchOutput) Conditions() FlowSchemaConditionPatchArrayOutput { return o.ApplyT(func(v FlowSchemaStatusPatch) []FlowSchemaConditionPatch { return v.Conditions }).(FlowSchemaConditionPatchArrayOutput) @@ -1897,6 +2180,12 @@ func (o FlowSchemaStatusPatchPtrOutput) ToFlowSchemaStatusPatchPtrOutputWithCont return o } +func (o FlowSchemaStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FlowSchemaStatusPatch] { + return pulumix.Output[*FlowSchemaStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o FlowSchemaStatusPatchPtrOutput) Elem() FlowSchemaStatusPatchOutput { return o.ApplyT(func(v *FlowSchemaStatusPatch) FlowSchemaStatusPatch { if v != nil { @@ -1952,6 +2241,12 @@ func (i GroupSubjectArgs) ToGroupSubjectOutputWithContext(ctx context.Context) G return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectOutput) } +func (i GroupSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: i.ToGroupSubjectOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectArgs) ToGroupSubjectPtrOutput() GroupSubjectPtrOutput { return i.ToGroupSubjectPtrOutputWithContext(context.Background()) } @@ -1993,6 +2288,12 @@ func (i *groupSubjectPtrType) ToGroupSubjectPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPtrOutput) } +func (i *groupSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: i.ToGroupSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectOutput struct{ *pulumi.OutputState } @@ -2018,6 +2319,12 @@ func (o GroupSubjectOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Conte }).(GroupSubjectPtrOutput) } +func (o GroupSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubject] { + return pulumix.Output[GroupSubject]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v GroupSubject) string { return v.Name }).(pulumi.StringOutput) @@ -2037,6 +2344,12 @@ func (o GroupSubjectPtrOutput) ToGroupSubjectPtrOutputWithContext(ctx context.Co return o } +func (o GroupSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubject] { + return pulumix.Output[*GroupSubject]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPtrOutput) Elem() GroupSubjectOutput { return o.ApplyT(func(v *GroupSubject) GroupSubject { if v != nil { @@ -2092,6 +2405,12 @@ func (i GroupSubjectPatchArgs) ToGroupSubjectPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchOutput) } +func (i GroupSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i GroupSubjectPatchArgs) ToGroupSubjectPatchPtrOutput() GroupSubjectPatchPtrOutput { return i.ToGroupSubjectPatchPtrOutputWithContext(context.Background()) } @@ -2133,6 +2452,12 @@ func (i *groupSubjectPatchPtrType) ToGroupSubjectPatchPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(GroupSubjectPatchPtrOutput) } +func (i *groupSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: i.ToGroupSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // GroupSubject holds detailed information for group-kind subject. type GroupSubjectPatchOutput struct{ *pulumi.OutputState } @@ -2158,6 +2483,12 @@ func (o GroupSubjectPatchOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx con }).(GroupSubjectPatchPtrOutput) } +func (o GroupSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[GroupSubjectPatch] { + return pulumix.Output[GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + // name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. func (o GroupSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v GroupSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -2177,6 +2508,12 @@ func (o GroupSubjectPatchPtrOutput) ToGroupSubjectPatchPtrOutputWithContext(ctx return o } +func (o GroupSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupSubjectPatch] { + return pulumix.Output[*GroupSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o GroupSubjectPatchPtrOutput) Elem() GroupSubjectPatchOutput { return o.ApplyT(func(v *GroupSubjectPatch) GroupSubjectPatch { if v != nil { @@ -2236,6 +2573,12 @@ func (i LimitResponseArgs) ToLimitResponseOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LimitResponseOutput) } +func (i LimitResponseArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: i.ToLimitResponseOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponseArgs) ToLimitResponsePtrOutput() LimitResponsePtrOutput { return i.ToLimitResponsePtrOutputWithContext(context.Background()) } @@ -2277,6 +2620,12 @@ func (i *limitResponsePtrType) ToLimitResponsePtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePtrOutput) } +func (i *limitResponsePtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: i.ToLimitResponsePtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponseOutput struct{ *pulumi.OutputState } @@ -2302,6 +2651,12 @@ func (o LimitResponseOutput) ToLimitResponsePtrOutputWithContext(ctx context.Con }).(LimitResponsePtrOutput) } +func (o LimitResponseOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponse] { + return pulumix.Output[LimitResponse]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponseOutput) Queuing() QueuingConfigurationPtrOutput { return o.ApplyT(func(v LimitResponse) *QueuingConfiguration { return v.Queuing }).(QueuingConfigurationPtrOutput) @@ -2326,6 +2681,12 @@ func (o LimitResponsePtrOutput) ToLimitResponsePtrOutputWithContext(ctx context. return o } +func (o LimitResponsePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponse] { + return pulumix.Output[*LimitResponse]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePtrOutput) Elem() LimitResponseOutput { return o.ApplyT(func(v *LimitResponse) LimitResponse { if v != nil { @@ -2395,6 +2756,12 @@ func (i LimitResponsePatchArgs) ToLimitResponsePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchOutput) } +func (i LimitResponsePatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitResponsePatchArgs) ToLimitResponsePatchPtrOutput() LimitResponsePatchPtrOutput { return i.ToLimitResponsePatchPtrOutputWithContext(context.Background()) } @@ -2436,6 +2803,12 @@ func (i *limitResponsePatchPtrType) ToLimitResponsePatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LimitResponsePatchPtrOutput) } +func (i *limitResponsePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: i.ToLimitResponsePatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitResponse defines how to handle requests that can not be executed right now. type LimitResponsePatchOutput struct{ *pulumi.OutputState } @@ -2461,6 +2834,12 @@ func (o LimitResponsePatchOutput) ToLimitResponsePatchPtrOutputWithContext(ctx c }).(LimitResponsePatchPtrOutput) } +func (o LimitResponsePatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitResponsePatch] { + return pulumix.Output[LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + // `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. func (o LimitResponsePatchOutput) Queuing() QueuingConfigurationPatchPtrOutput { return o.ApplyT(func(v LimitResponsePatch) *QueuingConfigurationPatch { return v.Queuing }).(QueuingConfigurationPatchPtrOutput) @@ -2485,6 +2864,12 @@ func (o LimitResponsePatchPtrOutput) ToLimitResponsePatchPtrOutputWithContext(ct return o } +func (o LimitResponsePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitResponsePatch] { + return pulumix.Output[*LimitResponsePatch]{ + OutputState: o.OutputState, + } +} + func (o LimitResponsePatchPtrOutput) Elem() LimitResponsePatchOutput { return o.ApplyT(func(v *LimitResponsePatch) LimitResponsePatch { if v != nil { @@ -2586,6 +2971,12 @@ func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationOutput) } +func (i LimitedPriorityLevelConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationArgs) ToLimitedPriorityLevelConfigurationPtrOutput() LimitedPriorityLevelConfigurationPtrOutput { return i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(context.Background()) } @@ -2627,6 +3018,12 @@ func (i *limitedPriorityLevelConfigurationPtrType) ToLimitedPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPtrOutput) } +func (i *limitedPriorityLevelConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2654,6 +3051,12 @@ func (o LimitedPriorityLevelConfigurationOutput) ToLimitedPriorityLevelConfigura }).(LimitedPriorityLevelConfigurationPtrOutput) } +func (o LimitedPriorityLevelConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfiguration] { + return pulumix.Output[LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + // `borrowingLimitPercent`, if present, configures a limit on how many seats this priority level can borrow from other priority levels. The limit is known as this level's BorrowingConcurrencyLimit (BorrowingCL) and is a limit on the total number of seats that this level may borrow at any one time. This field holds the ratio of that limit to the level's nominal concurrency limit. When this field is non-nil, it must hold a non-negative integer and the limit is calculated as follows. // // BorrowingCL(i) = round( NominalCL(i) * borrowingLimitPercent(i)/100.0 ) @@ -2698,6 +3101,12 @@ func (o LimitedPriorityLevelConfigurationPtrOutput) ToLimitedPriorityLevelConfig return o } +func (o LimitedPriorityLevelConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfiguration] { + return pulumix.Output[*LimitedPriorityLevelConfiguration]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPtrOutput) Elem() LimitedPriorityLevelConfigurationOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfiguration) LimitedPriorityLevelConfiguration { if v != nil { @@ -2829,6 +3238,12 @@ func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfig return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchOutput) } +func (i LimitedPriorityLevelConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i LimitedPriorityLevelConfigurationPatchArgs) ToLimitedPriorityLevelConfigurationPatchPtrOutput() LimitedPriorityLevelConfigurationPatchPtrOutput { return i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -2870,6 +3285,12 @@ func (i *limitedPriorityLevelConfigurationPatchPtrType) ToLimitedPriorityLevelCo return pulumi.ToOutputWithContext(ctx, i).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (i *limitedPriorityLevelConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: i.ToLimitedPriorityLevelConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: // - How are requests for this priority level limited? // - What should be done with requests that exceed the limit? @@ -2897,6 +3318,12 @@ func (o LimitedPriorityLevelConfigurationPatchOutput) ToLimitedPriorityLevelConf }).(LimitedPriorityLevelConfigurationPatchPtrOutput) } +func (o LimitedPriorityLevelConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `borrowingLimitPercent`, if present, configures a limit on how many seats this priority level can borrow from other priority levels. The limit is known as this level's BorrowingConcurrencyLimit (BorrowingCL) and is a limit on the total number of seats that this level may borrow at any one time. This field holds the ratio of that limit to the level's nominal concurrency limit. When this field is non-nil, it must hold a non-negative integer and the limit is calculated as follows. // // BorrowingCL(i) = round( NominalCL(i) * borrowingLimitPercent(i)/100.0 ) @@ -2941,6 +3368,12 @@ func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToLimitedPriorityLevelC return o } +func (o LimitedPriorityLevelConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LimitedPriorityLevelConfigurationPatch] { + return pulumix.Output[*LimitedPriorityLevelConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o LimitedPriorityLevelConfigurationPatchPtrOutput) Elem() LimitedPriorityLevelConfigurationPatchOutput { return o.ApplyT(func(v *LimitedPriorityLevelConfigurationPatch) LimitedPriorityLevelConfigurationPatch { if v != nil { @@ -3052,6 +3485,12 @@ func (i NonResourcePolicyRuleArgs) ToNonResourcePolicyRuleOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleOutput) } +func (i NonResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRuleArrayInput is an input type that accepts NonResourcePolicyRuleArray and NonResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRuleArrayInput` via: // @@ -3077,6 +3516,12 @@ func (i NonResourcePolicyRuleArray) ToNonResourcePolicyRuleArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRuleArrayOutput) } +func (i NonResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: i.ToNonResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -3092,6 +3537,12 @@ func (o NonResourcePolicyRuleOutput) ToNonResourcePolicyRuleOutputWithContext(ct return o } +func (o NonResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRule] { + return pulumix.Output[NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -3122,6 +3573,12 @@ func (o NonResourcePolicyRuleArrayOutput) ToNonResourcePolicyRuleArrayOutputWith return o } +func (o NonResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRule] { + return pulumix.Output[[]NonResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRule { return vs[0].([]NonResourcePolicyRule)[vs[1].(int)] @@ -3179,6 +3636,12 @@ func (i NonResourcePolicyRulePatchArgs) ToNonResourcePolicyRulePatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchOutput) } +func (i NonResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRulePatchArrayInput is an input type that accepts NonResourcePolicyRulePatchArray and NonResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `NonResourcePolicyRulePatchArrayInput` via: // @@ -3204,6 +3667,12 @@ func (i NonResourcePolicyRulePatchArray) ToNonResourcePolicyRulePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(NonResourcePolicyRulePatchArrayOutput) } +func (i NonResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: i.ToNonResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. type NonResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -3219,6 +3688,12 @@ func (o NonResourcePolicyRulePatchOutput) ToNonResourcePolicyRulePatchOutputWith return o } +func (o NonResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NonResourcePolicyRulePatch] { + return pulumix.Output[NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: // - "/healthz" is legal // - "/hea*" is illegal @@ -3249,6 +3724,12 @@ func (o NonResourcePolicyRulePatchArrayOutput) ToNonResourcePolicyRulePatchArray return o } +func (o NonResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NonResourcePolicyRulePatch] { + return pulumix.Output[[]NonResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NonResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) NonResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NonResourcePolicyRulePatch { return vs[0].([]NonResourcePolicyRulePatch)[vs[1].(int)] @@ -3298,6 +3779,12 @@ func (i PolicyRulesWithSubjectsArgs) ToPolicyRulesWithSubjectsOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsOutput) } +func (i PolicyRulesWithSubjectsArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsArrayInput is an input type that accepts PolicyRulesWithSubjectsArray and PolicyRulesWithSubjectsArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsArrayInput` via: // @@ -3323,6 +3810,12 @@ func (i PolicyRulesWithSubjectsArray) ToPolicyRulesWithSubjectsArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsArrayOutput) } +func (i PolicyRulesWithSubjectsArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: i.ToPolicyRulesWithSubjectsArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsOutput struct{ *pulumi.OutputState } @@ -3338,6 +3831,12 @@ func (o PolicyRulesWithSubjectsOutput) ToPolicyRulesWithSubjectsOutputWithContex return o } +func (o PolicyRulesWithSubjectsOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjects] { + return pulumix.Output[PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsOutput) NonResourceRules() NonResourcePolicyRuleArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjects) []NonResourcePolicyRule { return v.NonResourceRules }).(NonResourcePolicyRuleArrayOutput) @@ -3367,6 +3866,12 @@ func (o PolicyRulesWithSubjectsArrayOutput) ToPolicyRulesWithSubjectsArrayOutput return o } +func (o PolicyRulesWithSubjectsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjects] { + return pulumix.Output[[]PolicyRulesWithSubjects]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjects { return vs[0].([]PolicyRulesWithSubjects)[vs[1].(int)] @@ -3416,6 +3921,12 @@ func (i PolicyRulesWithSubjectsPatchArgs) ToPolicyRulesWithSubjectsPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchOutput) } +func (i PolicyRulesWithSubjectsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjectsPatchArrayInput is an input type that accepts PolicyRulesWithSubjectsPatchArray and PolicyRulesWithSubjectsPatchArrayOutput values. // You can construct a concrete instance of `PolicyRulesWithSubjectsPatchArrayInput` via: // @@ -3441,6 +3952,12 @@ func (i PolicyRulesWithSubjectsPatchArray) ToPolicyRulesWithSubjectsPatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(PolicyRulesWithSubjectsPatchArrayOutput) } +func (i PolicyRulesWithSubjectsPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: i.ToPolicyRulesWithSubjectsPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. type PolicyRulesWithSubjectsPatchOutput struct{ *pulumi.OutputState } @@ -3456,6 +3973,12 @@ func (o PolicyRulesWithSubjectsPatchOutput) ToPolicyRulesWithSubjectsPatchOutput return o } +func (o PolicyRulesWithSubjectsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulesWithSubjectsPatch] { + return pulumix.Output[PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. func (o PolicyRulesWithSubjectsPatchOutput) NonResourceRules() NonResourcePolicyRulePatchArrayOutput { return o.ApplyT(func(v PolicyRulesWithSubjectsPatch) []NonResourcePolicyRulePatch { return v.NonResourceRules }).(NonResourcePolicyRulePatchArrayOutput) @@ -3485,6 +4008,12 @@ func (o PolicyRulesWithSubjectsPatchArrayOutput) ToPolicyRulesWithSubjectsPatchA return o } +func (o PolicyRulesWithSubjectsPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulesWithSubjectsPatch] { + return pulumix.Output[[]PolicyRulesWithSubjectsPatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulesWithSubjectsPatchArrayOutput) Index(i pulumi.IntInput) PolicyRulesWithSubjectsPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulesWithSubjectsPatch { return vs[0].([]PolicyRulesWithSubjectsPatch)[vs[1].(int)] @@ -3542,6 +4071,12 @@ func (i PriorityLevelConfigurationTypeArgs) ToPriorityLevelConfigurationTypeOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeOutput) } +func (i PriorityLevelConfigurationTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationTypeArrayInput is an input type that accepts PriorityLevelConfigurationTypeArray and PriorityLevelConfigurationTypeArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationTypeArrayInput` via: // @@ -3567,6 +4102,12 @@ func (i PriorityLevelConfigurationTypeArray) ToPriorityLevelConfigurationTypeArr return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationTypeArrayOutput) } +func (i PriorityLevelConfigurationTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: i.ToPriorityLevelConfigurationTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationTypeOutput struct{ *pulumi.OutputState } @@ -3582,6 +4123,12 @@ func (o PriorityLevelConfigurationTypeOutput) ToPriorityLevelConfigurationTypeOu return o } +func (o PriorityLevelConfigurationTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationType] { + return pulumix.Output[PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3621,6 +4168,12 @@ func (o PriorityLevelConfigurationTypeArrayOutput) ToPriorityLevelConfigurationT return o } +func (o PriorityLevelConfigurationTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationType] { + return pulumix.Output[[]PriorityLevelConfigurationType]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationTypeArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationType { return vs[0].([]PriorityLevelConfigurationType)[vs[1].(int)] @@ -3678,6 +4231,12 @@ func (i PriorityLevelConfigurationConditionArgs) ToPriorityLevelConfigurationCon return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionOutput) } +func (i PriorityLevelConfigurationConditionArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionArrayInput is an input type that accepts PriorityLevelConfigurationConditionArray and PriorityLevelConfigurationConditionArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionArrayInput` via: // @@ -3703,6 +4262,12 @@ func (i PriorityLevelConfigurationConditionArray) ToPriorityLevelConfigurationCo return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionArrayOutput) } +func (i PriorityLevelConfigurationConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: i.ToPriorityLevelConfigurationConditionArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionOutput struct{ *pulumi.OutputState } @@ -3718,6 +4283,12 @@ func (o PriorityLevelConfigurationConditionOutput) ToPriorityLevelConfigurationC return o } +func (o PriorityLevelConfigurationConditionOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationCondition] { + return pulumix.Output[PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationCondition) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3757,6 +4328,12 @@ func (o PriorityLevelConfigurationConditionArrayOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationCondition] { + return pulumix.Output[[]PriorityLevelConfigurationCondition]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationCondition { return vs[0].([]PriorityLevelConfigurationCondition)[vs[1].(int)] @@ -3814,6 +4391,12 @@ func (i PriorityLevelConfigurationConditionPatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchOutput) } +func (i PriorityLevelConfigurationConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationConditionPatchArrayInput is an input type that accepts PriorityLevelConfigurationConditionPatchArray and PriorityLevelConfigurationConditionPatchArrayOutput values. // You can construct a concrete instance of `PriorityLevelConfigurationConditionPatchArrayInput` via: // @@ -3839,6 +4422,12 @@ func (i PriorityLevelConfigurationConditionPatchArray) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationConditionPatchArrayOutput) } +func (i PriorityLevelConfigurationConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: i.ToPriorityLevelConfigurationConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationCondition defines the condition of priority level. type PriorityLevelConfigurationConditionPatchOutput struct{ *pulumi.OutputState } @@ -3854,6 +4443,12 @@ func (o PriorityLevelConfigurationConditionPatchOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + // `lastTransitionTime` is the last time the condition transitioned from one status to another. func (o PriorityLevelConfigurationConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -3893,6 +4488,12 @@ func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToPriorityLevelConf return o } +func (o PriorityLevelConfigurationConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityLevelConfigurationConditionPatch] { + return pulumix.Output[[]PriorityLevelConfigurationConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationConditionPatchArrayOutput) Index(i pulumi.IntInput) PriorityLevelConfigurationConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityLevelConfigurationConditionPatch { return vs[0].([]PriorityLevelConfigurationConditionPatch)[vs[1].(int)] @@ -3946,6 +4547,12 @@ func (i PriorityLevelConfigurationListTypeArgs) ToPriorityLevelConfigurationList return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationListTypeOutput) } +func (i PriorityLevelConfigurationListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: i.ToPriorityLevelConfigurationListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. type PriorityLevelConfigurationListTypeOutput struct{ *pulumi.OutputState } @@ -3961,6 +4568,12 @@ func (o PriorityLevelConfigurationListTypeOutput) ToPriorityLevelConfigurationLi return o } +func (o PriorityLevelConfigurationListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationListType] { + return pulumix.Output[PriorityLevelConfigurationListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4032,6 +4645,12 @@ func (i PriorityLevelConfigurationPatchTypeArgs) ToPriorityLevelConfigurationPat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationPatchTypeOutput) } +func (i PriorityLevelConfigurationPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: i.ToPriorityLevelConfigurationPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfigurationPatchTypeOutput struct{ *pulumi.OutputState } @@ -4047,6 +4666,12 @@ func (o PriorityLevelConfigurationPatchTypeOutput) ToPriorityLevelConfigurationP return o } +func (o PriorityLevelConfigurationPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationPatchType] { + return pulumix.Output[PriorityLevelConfigurationPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityLevelConfigurationPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4107,6 +4732,12 @@ func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationRef return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferenceOutput) } +func (i PriorityLevelConfigurationReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferenceOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferenceArgs) ToPriorityLevelConfigurationReferencePtrOutput() PriorityLevelConfigurationReferencePtrOutput { return i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(context.Background()) } @@ -4148,6 +4779,12 @@ func (i *priorityLevelConfigurationReferencePtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePtrOutput) } +func (i *priorityLevelConfigurationReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: i.ToPriorityLevelConfigurationReferencePtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferenceOutput struct{ *pulumi.OutputState } @@ -4173,6 +4810,12 @@ func (o PriorityLevelConfigurationReferenceOutput) ToPriorityLevelConfigurationR }).(PriorityLevelConfigurationReferencePtrOutput) } +func (o PriorityLevelConfigurationReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReference] { + return pulumix.Output[PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferenceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v PriorityLevelConfigurationReference) string { return v.Name }).(pulumi.StringOutput) @@ -4192,6 +4835,12 @@ func (o PriorityLevelConfigurationReferencePtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReference] { + return pulumix.Output[*PriorityLevelConfigurationReference]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePtrOutput) Elem() PriorityLevelConfigurationReferenceOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReference) PriorityLevelConfigurationReference { if v != nil { @@ -4247,6 +4896,12 @@ func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurati return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchOutput) } +func (i PriorityLevelConfigurationReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationReferencePatchArgs) ToPriorityLevelConfigurationReferencePatchPtrOutput() PriorityLevelConfigurationReferencePatchPtrOutput { return i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(context.Background()) } @@ -4288,6 +4943,12 @@ func (i *priorityLevelConfigurationReferencePatchPtrType) ToPriorityLevelConfigu return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (i *priorityLevelConfigurationReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: i.ToPriorityLevelConfigurationReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. type PriorityLevelConfigurationReferencePatchOutput struct{ *pulumi.OutputState } @@ -4313,6 +4974,12 @@ func (o PriorityLevelConfigurationReferencePatchOutput) ToPriorityLevelConfigura }).(PriorityLevelConfigurationReferencePatchPtrOutput) } +func (o PriorityLevelConfigurationReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of the priority level configuration being referenced Required. func (o PriorityLevelConfigurationReferencePatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -4332,6 +4999,12 @@ func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToPriorityLevelConfig return o } +func (o PriorityLevelConfigurationReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationReferencePatch] { + return pulumix.Output[*PriorityLevelConfigurationReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationReferencePatchPtrOutput) Elem() PriorityLevelConfigurationReferencePatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationReferencePatch) PriorityLevelConfigurationReferencePatch { if v != nil { @@ -4395,6 +5068,12 @@ func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecOutp return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecOutput) } +func (i PriorityLevelConfigurationSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecArgs) ToPriorityLevelConfigurationSpecPtrOutput() PriorityLevelConfigurationSpecPtrOutput { return i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(context.Background()) } @@ -4436,6 +5115,12 @@ func (i *priorityLevelConfigurationSpecPtrType) ToPriorityLevelConfigurationSpec return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPtrOutput) } +func (i *priorityLevelConfigurationSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: i.ToPriorityLevelConfigurationSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecOutput struct{ *pulumi.OutputState } @@ -4461,6 +5146,12 @@ func (o PriorityLevelConfigurationSpecOutput) ToPriorityLevelConfigurationSpecPt }).(PriorityLevelConfigurationSpecPtrOutput) } +func (o PriorityLevelConfigurationSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpec] { + return pulumix.Output[PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + // `exempt` specifies how requests are handled for an exempt priority level. This field MUST be empty if `type` is `"Limited"`. This field MAY be non-empty if `type` is `"Exempt"`. If empty and `type` is `"Exempt"` then the default values for `ExemptPriorityLevelConfiguration` apply. func (o PriorityLevelConfigurationSpecOutput) Exempt() ExemptPriorityLevelConfigurationPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpec) *ExemptPriorityLevelConfiguration { return v.Exempt }).(ExemptPriorityLevelConfigurationPtrOutput) @@ -4490,6 +5181,12 @@ func (o PriorityLevelConfigurationSpecPtrOutput) ToPriorityLevelConfigurationSpe return o } +func (o PriorityLevelConfigurationSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpec] { + return pulumix.Output[*PriorityLevelConfigurationSpec]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPtrOutput) Elem() PriorityLevelConfigurationSpecOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpec) PriorityLevelConfigurationSpec { if v != nil { @@ -4573,6 +5270,12 @@ func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpe return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchOutput) } +func (i PriorityLevelConfigurationSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationSpecPatchArgs) ToPriorityLevelConfigurationSpecPatchPtrOutput() PriorityLevelConfigurationSpecPatchPtrOutput { return i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(context.Background()) } @@ -4614,6 +5317,12 @@ func (i *priorityLevelConfigurationSpecPatchPtrType) ToPriorityLevelConfiguratio return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (i *priorityLevelConfigurationSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: i.ToPriorityLevelConfigurationSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationSpec specifies the configuration of a priority level. type PriorityLevelConfigurationSpecPatchOutput struct{ *pulumi.OutputState } @@ -4639,6 +5348,12 @@ func (o PriorityLevelConfigurationSpecPatchOutput) ToPriorityLevelConfigurationS }).(PriorityLevelConfigurationSpecPatchPtrOutput) } +func (o PriorityLevelConfigurationSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + // `exempt` specifies how requests are handled for an exempt priority level. This field MUST be empty if `type` is `"Limited"`. This field MAY be non-empty if `type` is `"Exempt"`. If empty and `type` is `"Exempt"` then the default values for `ExemptPriorityLevelConfiguration` apply. func (o PriorityLevelConfigurationSpecPatchOutput) Exempt() ExemptPriorityLevelConfigurationPatchPtrOutput { return o.ApplyT(func(v PriorityLevelConfigurationSpecPatch) *ExemptPriorityLevelConfigurationPatch { return v.Exempt }).(ExemptPriorityLevelConfigurationPatchPtrOutput) @@ -4668,6 +5383,12 @@ func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToPriorityLevelConfigurati return o } +func (o PriorityLevelConfigurationSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationSpecPatch] { + return pulumix.Output[*PriorityLevelConfigurationSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationSpecPatchPtrOutput) Elem() PriorityLevelConfigurationSpecPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationSpecPatch) PriorityLevelConfigurationSpecPatch { if v != nil { @@ -4743,6 +5464,12 @@ func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatus return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusOutput) } +func (i PriorityLevelConfigurationStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusArgs) ToPriorityLevelConfigurationStatusPtrOutput() PriorityLevelConfigurationStatusPtrOutput { return i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(context.Background()) } @@ -4784,6 +5511,12 @@ func (i *priorityLevelConfigurationStatusPtrType) ToPriorityLevelConfigurationSt return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPtrOutput) } +func (i *priorityLevelConfigurationStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: i.ToPriorityLevelConfigurationStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusOutput struct{ *pulumi.OutputState } @@ -4809,6 +5542,12 @@ func (o PriorityLevelConfigurationStatusOutput) ToPriorityLevelConfigurationStat }).(PriorityLevelConfigurationStatusPtrOutput) } +func (o PriorityLevelConfigurationStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatus] { + return pulumix.Output[PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusOutput) Conditions() PriorityLevelConfigurationConditionArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatus) []PriorityLevelConfigurationCondition { return v.Conditions }).(PriorityLevelConfigurationConditionArrayOutput) @@ -4828,6 +5567,12 @@ func (o PriorityLevelConfigurationStatusPtrOutput) ToPriorityLevelConfigurationS return o } +func (o PriorityLevelConfigurationStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatus] { + return pulumix.Output[*PriorityLevelConfigurationStatus]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPtrOutput) Elem() PriorityLevelConfigurationStatusOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatus) PriorityLevelConfigurationStatus { if v != nil { @@ -4883,6 +5628,12 @@ func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationS return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchOutput) } +func (i PriorityLevelConfigurationStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PriorityLevelConfigurationStatusPatchArgs) ToPriorityLevelConfigurationStatusPatchPtrOutput() PriorityLevelConfigurationStatusPatchPtrOutput { return i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(context.Background()) } @@ -4924,6 +5675,12 @@ func (i *priorityLevelConfigurationStatusPatchPtrType) ToPriorityLevelConfigurat return pulumi.ToOutputWithContext(ctx, i).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (i *priorityLevelConfigurationStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: i.ToPriorityLevelConfigurationStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PriorityLevelConfigurationStatus represents the current state of a "request-priority". type PriorityLevelConfigurationStatusPatchOutput struct{ *pulumi.OutputState } @@ -4949,6 +5706,12 @@ func (o PriorityLevelConfigurationStatusPatchOutput) ToPriorityLevelConfiguratio }).(PriorityLevelConfigurationStatusPatchPtrOutput) } +func (o PriorityLevelConfigurationStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + // `conditions` is the current state of "request-priority". func (o PriorityLevelConfigurationStatusPatchOutput) Conditions() PriorityLevelConfigurationConditionPatchArrayOutput { return o.ApplyT(func(v PriorityLevelConfigurationStatusPatch) []PriorityLevelConfigurationConditionPatch { @@ -4970,6 +5733,12 @@ func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToPriorityLevelConfigura return o } +func (o PriorityLevelConfigurationStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityLevelConfigurationStatusPatch] { + return pulumix.Output[*PriorityLevelConfigurationStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityLevelConfigurationStatusPatchPtrOutput) Elem() PriorityLevelConfigurationStatusPatchOutput { return o.ApplyT(func(v *PriorityLevelConfigurationStatusPatch) PriorityLevelConfigurationStatusPatch { if v != nil { @@ -5033,6 +5802,12 @@ func (i QueuingConfigurationArgs) ToQueuingConfigurationOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationOutput) } +func (i QueuingConfigurationArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationArgs) ToQueuingConfigurationPtrOutput() QueuingConfigurationPtrOutput { return i.ToQueuingConfigurationPtrOutputWithContext(context.Background()) } @@ -5074,6 +5849,12 @@ func (i *queuingConfigurationPtrType) ToQueuingConfigurationPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPtrOutput) } +func (i *queuingConfigurationPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: i.ToQueuingConfigurationPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationOutput struct{ *pulumi.OutputState } @@ -5099,6 +5880,12 @@ func (o QueuingConfigurationOutput) ToQueuingConfigurationPtrOutputWithContext(c }).(QueuingConfigurationPtrOutput) } +func (o QueuingConfigurationOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfiguration] { + return pulumix.Output[QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfiguration) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -5128,6 +5915,12 @@ func (o QueuingConfigurationPtrOutput) ToQueuingConfigurationPtrOutputWithContex return o } +func (o QueuingConfigurationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfiguration] { + return pulumix.Output[*QueuingConfiguration]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPtrOutput) Elem() QueuingConfigurationOutput { return o.ApplyT(func(v *QueuingConfiguration) QueuingConfiguration { if v != nil { @@ -5211,6 +6004,12 @@ func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchOutput) } +func (i QueuingConfigurationPatchArgs) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchOutputWithContext(ctx).OutputState, + } +} + func (i QueuingConfigurationPatchArgs) ToQueuingConfigurationPatchPtrOutput() QueuingConfigurationPatchPtrOutput { return i.ToQueuingConfigurationPatchPtrOutputWithContext(context.Background()) } @@ -5252,6 +6051,12 @@ func (i *queuingConfigurationPatchPtrType) ToQueuingConfigurationPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(QueuingConfigurationPatchPtrOutput) } +func (i *queuingConfigurationPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: i.ToQueuingConfigurationPatchPtrOutputWithContext(ctx).OutputState, + } +} + // QueuingConfiguration holds the configuration parameters for queuing type QueuingConfigurationPatchOutput struct{ *pulumi.OutputState } @@ -5277,6 +6082,12 @@ func (o QueuingConfigurationPatchOutput) ToQueuingConfigurationPatchPtrOutputWit }).(QueuingConfigurationPatchPtrOutput) } +func (o QueuingConfigurationPatchOutput) ToOutput(ctx context.Context) pulumix.Output[QueuingConfigurationPatch] { + return pulumix.Output[QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + // `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. func (o QueuingConfigurationPatchOutput) HandSize() pulumi.IntPtrOutput { return o.ApplyT(func(v QueuingConfigurationPatch) *int { return v.HandSize }).(pulumi.IntPtrOutput) @@ -5306,6 +6117,12 @@ func (o QueuingConfigurationPatchPtrOutput) ToQueuingConfigurationPatchPtrOutput return o } +func (o QueuingConfigurationPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*QueuingConfigurationPatch] { + return pulumix.Output[*QueuingConfigurationPatch]{ + OutputState: o.OutputState, + } +} + func (o QueuingConfigurationPatchPtrOutput) Elem() QueuingConfigurationPatchOutput { return o.ApplyT(func(v *QueuingConfigurationPatch) QueuingConfigurationPatch { if v != nil { @@ -5397,6 +6214,12 @@ func (i ResourcePolicyRuleArgs) ToResourcePolicyRuleOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleOutput) } +func (i ResourcePolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRuleArrayInput is an input type that accepts ResourcePolicyRuleArray and ResourcePolicyRuleArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRuleArrayInput` via: // @@ -5422,6 +6245,12 @@ func (i ResourcePolicyRuleArray) ToResourcePolicyRuleArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRuleArrayOutput) } +func (i ResourcePolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: i.ToResourcePolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==""`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace. type ResourcePolicyRuleOutput struct{ *pulumi.OutputState } @@ -5437,6 +6266,12 @@ func (o ResourcePolicyRuleOutput) ToResourcePolicyRuleOutputWithContext(ctx cont return o } +func (o ResourcePolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRule] { + return pulumix.Output[ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -5476,6 +6311,12 @@ func (o ResourcePolicyRuleArrayOutput) ToResourcePolicyRuleArrayOutputWithContex return o } +func (o ResourcePolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRule] { + return pulumix.Output[[]ResourcePolicyRule]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRuleArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRule { return vs[0].([]ResourcePolicyRule)[vs[1].(int)] @@ -5533,6 +6374,12 @@ func (i ResourcePolicyRulePatchArgs) ToResourcePolicyRulePatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchOutput) } +func (i ResourcePolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRulePatchArrayInput is an input type that accepts ResourcePolicyRulePatchArray and ResourcePolicyRulePatchArrayOutput values. // You can construct a concrete instance of `ResourcePolicyRulePatchArrayInput` via: // @@ -5558,6 +6405,12 @@ func (i ResourcePolicyRulePatchArray) ToResourcePolicyRulePatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourcePolicyRulePatchArrayOutput) } +func (i ResourcePolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: i.ToResourcePolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==""`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace. type ResourcePolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -5573,6 +6426,12 @@ func (o ResourcePolicyRulePatchOutput) ToResourcePolicyRulePatchOutputWithContex return o } +func (o ResourcePolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourcePolicyRulePatch] { + return pulumix.Output[ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // `apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. func (o ResourcePolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v ResourcePolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -5612,6 +6471,12 @@ func (o ResourcePolicyRulePatchArrayOutput) ToResourcePolicyRulePatchArrayOutput return o } +func (o ResourcePolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourcePolicyRulePatch] { + return pulumix.Output[[]ResourcePolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourcePolicyRulePatchArrayOutput) Index(i pulumi.IntInput) ResourcePolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourcePolicyRulePatch { return vs[0].([]ResourcePolicyRulePatch)[vs[1].(int)] @@ -5657,6 +6522,12 @@ func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectOutput) } +func (i ServiceAccountSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectArgs) ToServiceAccountSubjectPtrOutput() ServiceAccountSubjectPtrOutput { return i.ToServiceAccountSubjectPtrOutputWithContext(context.Background()) } @@ -5698,6 +6569,12 @@ func (i *serviceAccountSubjectPtrType) ToServiceAccountSubjectPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPtrOutput) } +func (i *serviceAccountSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: i.ToServiceAccountSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectOutput struct{ *pulumi.OutputState } @@ -5723,6 +6600,12 @@ func (o ServiceAccountSubjectOutput) ToServiceAccountSubjectPtrOutputWithContext }).(ServiceAccountSubjectPtrOutput) } +func (o ServiceAccountSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubject] { + return pulumix.Output[ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v ServiceAccountSubject) string { return v.Name }).(pulumi.StringOutput) @@ -5747,6 +6630,12 @@ func (o ServiceAccountSubjectPtrOutput) ToServiceAccountSubjectPtrOutputWithCont return o } +func (o ServiceAccountSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubject] { + return pulumix.Output[*ServiceAccountSubject]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPtrOutput) Elem() ServiceAccountSubjectOutput { return o.ApplyT(func(v *ServiceAccountSubject) ServiceAccountSubject { if v != nil { @@ -5816,6 +6705,12 @@ func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchOutput) } +func (i ServiceAccountSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceAccountSubjectPatchArgs) ToServiceAccountSubjectPatchPtrOutput() ServiceAccountSubjectPatchPtrOutput { return i.ToServiceAccountSubjectPatchPtrOutputWithContext(context.Background()) } @@ -5857,6 +6752,12 @@ func (i *serviceAccountSubjectPatchPtrType) ToServiceAccountSubjectPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountSubjectPatchPtrOutput) } +func (i *serviceAccountSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: i.ToServiceAccountSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceAccountSubject holds detailed information for service-account-kind subject. type ServiceAccountSubjectPatchOutput struct{ *pulumi.OutputState } @@ -5882,6 +6783,12 @@ func (o ServiceAccountSubjectPatchOutput) ToServiceAccountSubjectPatchPtrOutputW }).(ServiceAccountSubjectPatchPtrOutput) } +func (o ServiceAccountSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceAccountSubjectPatch] { + return pulumix.Output[ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. func (o ServiceAccountSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceAccountSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -5906,6 +6813,12 @@ func (o ServiceAccountSubjectPatchPtrOutput) ToServiceAccountSubjectPatchPtrOutp return o } +func (o ServiceAccountSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceAccountSubjectPatch] { + return pulumix.Output[*ServiceAccountSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceAccountSubjectPatchPtrOutput) Elem() ServiceAccountSubjectPatchOutput { return o.ApplyT(func(v *ServiceAccountSubjectPatch) ServiceAccountSubjectPatch { if v != nil { @@ -5983,6 +6896,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -6008,6 +6927,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectOutput struct{ *pulumi.OutputState } @@ -6023,6 +6948,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + // `group` matches based on user group name. func (o SubjectOutput) Group() GroupSubjectPtrOutput { return o.ApplyT(func(v Subject) *GroupSubject { return v.Group }).(GroupSubjectPtrOutput) @@ -6057,6 +6988,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -6110,6 +7047,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -6135,6 +7078,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -6150,6 +7099,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + // `group` matches based on user group name. func (o SubjectPatchOutput) Group() GroupSubjectPatchPtrOutput { return o.ApplyT(func(v SubjectPatch) *GroupSubjectPatch { return v.Group }).(GroupSubjectPatchPtrOutput) @@ -6184,6 +7139,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] @@ -6225,6 +7186,12 @@ func (i UserSubjectArgs) ToUserSubjectOutputWithContext(ctx context.Context) Use return pulumi.ToOutputWithContext(ctx, i).(UserSubjectOutput) } +func (i UserSubjectArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: i.ToUserSubjectOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectArgs) ToUserSubjectPtrOutput() UserSubjectPtrOutput { return i.ToUserSubjectPtrOutputWithContext(context.Background()) } @@ -6266,6 +7233,12 @@ func (i *userSubjectPtrType) ToUserSubjectPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPtrOutput) } +func (i *userSubjectPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: i.ToUserSubjectPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectOutput struct{ *pulumi.OutputState } @@ -6291,6 +7264,12 @@ func (o UserSubjectOutput) ToUserSubjectPtrOutputWithContext(ctx context.Context }).(UserSubjectPtrOutput) } +func (o UserSubjectOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubject] { + return pulumix.Output[UserSubject]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v UserSubject) string { return v.Name }).(pulumi.StringOutput) @@ -6310,6 +7289,12 @@ func (o UserSubjectPtrOutput) ToUserSubjectPtrOutputWithContext(ctx context.Cont return o } +func (o UserSubjectPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubject] { + return pulumix.Output[*UserSubject]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPtrOutput) Elem() UserSubjectOutput { return o.ApplyT(func(v *UserSubject) UserSubject { if v != nil { @@ -6365,6 +7350,12 @@ func (i UserSubjectPatchArgs) ToUserSubjectPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchOutput) } +func (i UserSubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchOutputWithContext(ctx).OutputState, + } +} + func (i UserSubjectPatchArgs) ToUserSubjectPatchPtrOutput() UserSubjectPatchPtrOutput { return i.ToUserSubjectPatchPtrOutputWithContext(context.Background()) } @@ -6406,6 +7397,12 @@ func (i *userSubjectPatchPtrType) ToUserSubjectPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(UserSubjectPatchPtrOutput) } +func (i *userSubjectPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: i.ToUserSubjectPatchPtrOutputWithContext(ctx).OutputState, + } +} + // UserSubject holds detailed information for user-kind subject. type UserSubjectPatchOutput struct{ *pulumi.OutputState } @@ -6431,6 +7428,12 @@ func (o UserSubjectPatchOutput) ToUserSubjectPatchPtrOutputWithContext(ctx conte }).(UserSubjectPatchPtrOutput) } +func (o UserSubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[UserSubjectPatch] { + return pulumix.Output[UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + // `name` is the username that matches, or "*" to match all usernames. Required. func (o UserSubjectPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v UserSubjectPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -6450,6 +7453,12 @@ func (o UserSubjectPatchPtrOutput) ToUserSubjectPatchPtrOutputWithContext(ctx co return o } +func (o UserSubjectPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*UserSubjectPatch] { + return pulumix.Output[*UserSubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o UserSubjectPatchPtrOutput) Elem() UserSubjectPatchOutput { return o.ApplyT(func(v *UserSubjectPatch) UserSubjectPatch { if v != nil { diff --git a/sdk/go/kubernetes/helm/v3/pulumiTypes.go b/sdk/go/kubernetes/helm/v3/pulumiTypes.go index fcf5e7c35b..9b9fa16788 100644 --- a/sdk/go/kubernetes/helm/v3/pulumiTypes.go +++ b/sdk/go/kubernetes/helm/v3/pulumiTypes.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -70,6 +71,12 @@ func (i ReleaseStatusArgs) ToReleaseStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ReleaseStatusOutput) } +func (i ReleaseStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ReleaseStatus] { + return pulumix.Output[ReleaseStatus]{ + OutputState: i.ToReleaseStatusOutputWithContext(ctx).OutputState, + } +} + type ReleaseStatusOutput struct{ *pulumi.OutputState } func (ReleaseStatusOutput) ElementType() reflect.Type { @@ -84,6 +91,12 @@ func (o ReleaseStatusOutput) ToReleaseStatusOutputWithContext(ctx context.Contex return o } +func (o ReleaseStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ReleaseStatus] { + return pulumix.Output[ReleaseStatus]{ + OutputState: o.OutputState, + } +} + // The version number of the application being deployed. func (o ReleaseStatusOutput) AppVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ReleaseStatus) *string { return v.AppVersion }).(pulumi.StringPtrOutput) @@ -174,6 +187,12 @@ func (i RepositoryOptsArgs) ToRepositoryOptsOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(RepositoryOptsOutput) } +func (i RepositoryOptsArgs) ToOutput(ctx context.Context) pulumix.Output[RepositoryOpts] { + return pulumix.Output[RepositoryOpts]{ + OutputState: i.ToRepositoryOptsOutputWithContext(ctx).OutputState, + } +} + func (i RepositoryOptsArgs) ToRepositoryOptsPtrOutput() RepositoryOptsPtrOutput { return i.ToRepositoryOptsPtrOutputWithContext(context.Background()) } @@ -215,6 +234,12 @@ func (i *repositoryOptsPtrType) ToRepositoryOptsPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(RepositoryOptsPtrOutput) } +func (i *repositoryOptsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RepositoryOpts] { + return pulumix.Output[*RepositoryOpts]{ + OutputState: i.ToRepositoryOptsPtrOutputWithContext(ctx).OutputState, + } +} + // Specification defining the Helm chart repository to use. type RepositoryOptsOutput struct{ *pulumi.OutputState } @@ -240,6 +265,12 @@ func (o RepositoryOptsOutput) ToRepositoryOptsPtrOutputWithContext(ctx context.C }).(RepositoryOptsPtrOutput) } +func (o RepositoryOptsOutput) ToOutput(ctx context.Context) pulumix.Output[RepositoryOpts] { + return pulumix.Output[RepositoryOpts]{ + OutputState: o.OutputState, + } +} + // The Repository's CA File func (o RepositoryOptsOutput) CaFile() pulumi.StringPtrOutput { return o.ApplyT(func(v RepositoryOpts) *string { return v.CaFile }).(pulumi.StringPtrOutput) @@ -284,6 +315,12 @@ func (o RepositoryOptsPtrOutput) ToRepositoryOptsPtrOutputWithContext(ctx contex return o } +func (o RepositoryOptsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RepositoryOpts] { + return pulumix.Output[*RepositoryOpts]{ + OutputState: o.OutputState, + } +} + func (o RepositoryOptsPtrOutput) Elem() RepositoryOptsOutput { return o.ApplyT(func(v *RepositoryOpts) RepositoryOpts { if v != nil { diff --git a/sdk/go/kubernetes/helm/v3/release.go b/sdk/go/kubernetes/helm/v3/release.go index cc7492ff56..df63978630 100644 --- a/sdk/go/kubernetes/helm/v3/release.go +++ b/sdk/go/kubernetes/helm/v3/release.go @@ -10,6 +10,7 @@ import ( "errors" "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // A `Release` is an instance of a chart running in a Kubernetes cluster. A `Chart` is a Helm package. It contains all the @@ -578,6 +579,12 @@ func (i *Release) ToReleaseOutputWithContext(ctx context.Context) ReleaseOutput return pulumi.ToOutputWithContext(ctx, i).(ReleaseOutput) } +func (i *Release) ToOutput(ctx context.Context) pulumix.Output[*Release] { + return pulumix.Output[*Release]{ + OutputState: i.ToReleaseOutputWithContext(ctx).OutputState, + } +} + // ReleaseArrayInput is an input type that accepts ReleaseArray and ReleaseArrayOutput values. // You can construct a concrete instance of `ReleaseArrayInput` via: // @@ -603,6 +610,12 @@ func (i ReleaseArray) ToReleaseArrayOutputWithContext(ctx context.Context) Relea return pulumi.ToOutputWithContext(ctx, i).(ReleaseArrayOutput) } +func (i ReleaseArray) ToOutput(ctx context.Context) pulumix.Output[[]*Release] { + return pulumix.Output[[]*Release]{ + OutputState: i.ToReleaseArrayOutputWithContext(ctx).OutputState, + } +} + // ReleaseMapInput is an input type that accepts ReleaseMap and ReleaseMapOutput values. // You can construct a concrete instance of `ReleaseMapInput` via: // @@ -628,6 +641,12 @@ func (i ReleaseMap) ToReleaseMapOutputWithContext(ctx context.Context) ReleaseMa return pulumi.ToOutputWithContext(ctx, i).(ReleaseMapOutput) } +func (i ReleaseMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Release] { + return pulumix.Output[map[string]*Release]{ + OutputState: i.ToReleaseMapOutputWithContext(ctx).OutputState, + } +} + type ReleaseOutput struct{ *pulumi.OutputState } func (ReleaseOutput) ElementType() reflect.Type { @@ -642,6 +661,12 @@ func (o ReleaseOutput) ToReleaseOutputWithContext(ctx context.Context) ReleaseOu return o } +func (o ReleaseOutput) ToOutput(ctx context.Context) pulumix.Output[*Release] { + return pulumix.Output[*Release]{ + OutputState: o.OutputState, + } +} + // Whether to allow Null values in helm chart configs. func (o ReleaseOutput) AllowNullValues() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Release) pulumi.BoolPtrOutput { return v.AllowNullValues }).(pulumi.BoolPtrOutput) @@ -831,6 +856,12 @@ func (o ReleaseArrayOutput) ToReleaseArrayOutputWithContext(ctx context.Context) return o } +func (o ReleaseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Release] { + return pulumix.Output[[]*Release]{ + OutputState: o.OutputState, + } +} + func (o ReleaseArrayOutput) Index(i pulumi.IntInput) ReleaseOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Release { return vs[0].([]*Release)[vs[1].(int)] @@ -851,6 +882,12 @@ func (o ReleaseMapOutput) ToReleaseMapOutputWithContext(ctx context.Context) Rel return o } +func (o ReleaseMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Release] { + return pulumix.Output[map[string]*Release]{ + OutputState: o.OutputState, + } +} + func (o ReleaseMapOutput) MapIndex(k pulumi.StringInput) ReleaseOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Release { return vs[0].(map[string]*Release)[vs[1].(string)] diff --git a/sdk/go/kubernetes/meta/v1/pulumiTypes.go b/sdk/go/kubernetes/meta/v1/pulumiTypes.go index 8afc8d2448..f59bd3cb56 100644 --- a/sdk/go/kubernetes/meta/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/meta/v1/pulumiTypes.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -68,6 +69,12 @@ func (i APIGroupArgs) ToAPIGroupOutputWithContext(ctx context.Context) APIGroupO return pulumi.ToOutputWithContext(ctx, i).(APIGroupOutput) } +func (i APIGroupArgs) ToOutput(ctx context.Context) pulumix.Output[APIGroup] { + return pulumix.Output[APIGroup]{ + OutputState: i.ToAPIGroupOutputWithContext(ctx).OutputState, + } +} + // APIGroupArrayInput is an input type that accepts APIGroupArray and APIGroupArrayOutput values. // You can construct a concrete instance of `APIGroupArrayInput` via: // @@ -93,6 +100,12 @@ func (i APIGroupArray) ToAPIGroupArrayOutputWithContext(ctx context.Context) API return pulumi.ToOutputWithContext(ctx, i).(APIGroupArrayOutput) } +func (i APIGroupArray) ToOutput(ctx context.Context) pulumix.Output[[]APIGroup] { + return pulumix.Output[[]APIGroup]{ + OutputState: i.ToAPIGroupArrayOutputWithContext(ctx).OutputState, + } +} + // APIGroup contains the name, the supported versions, and the preferred version of a group. type APIGroupOutput struct{ *pulumi.OutputState } @@ -108,6 +121,12 @@ func (o APIGroupOutput) ToAPIGroupOutputWithContext(ctx context.Context) APIGrou return o } +func (o APIGroupOutput) ToOutput(ctx context.Context) pulumix.Output[APIGroup] { + return pulumix.Output[APIGroup]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIGroupOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIGroup) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -152,6 +171,12 @@ func (o APIGroupArrayOutput) ToAPIGroupArrayOutputWithContext(ctx context.Contex return o } +func (o APIGroupArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIGroup] { + return pulumix.Output[[]APIGroup]{ + OutputState: o.OutputState, + } +} + func (o APIGroupArrayOutput) Index(i pulumi.IntInput) APIGroupOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIGroup { return vs[0].([]APIGroup)[vs[1].(int)] @@ -201,6 +226,12 @@ func (i APIGroupListArgs) ToAPIGroupListOutputWithContext(ctx context.Context) A return pulumi.ToOutputWithContext(ctx, i).(APIGroupListOutput) } +func (i APIGroupListArgs) ToOutput(ctx context.Context) pulumix.Output[APIGroupList] { + return pulumix.Output[APIGroupList]{ + OutputState: i.ToAPIGroupListOutputWithContext(ctx).OutputState, + } +} + // APIGroupList is a list of APIGroup, to allow clients to discover the API at /apis. type APIGroupListOutput struct{ *pulumi.OutputState } @@ -216,6 +247,12 @@ func (o APIGroupListOutput) ToAPIGroupListOutputWithContext(ctx context.Context) return o } +func (o APIGroupListOutput) ToOutput(ctx context.Context) pulumix.Output[APIGroupList] { + return pulumix.Output[APIGroupList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIGroupListOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIGroupList) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -286,6 +323,12 @@ func (i APIGroupPatchArgs) ToAPIGroupPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(APIGroupPatchOutput) } +func (i APIGroupPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIGroupPatch] { + return pulumix.Output[APIGroupPatch]{ + OutputState: i.ToAPIGroupPatchOutputWithContext(ctx).OutputState, + } +} + // APIGroup contains the name, the supported versions, and the preferred version of a group. type APIGroupPatchOutput struct{ *pulumi.OutputState } @@ -301,6 +344,12 @@ func (o APIGroupPatchOutput) ToAPIGroupPatchOutputWithContext(ctx context.Contex return o } +func (o APIGroupPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIGroupPatch] { + return pulumix.Output[APIGroupPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIGroupPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIGroupPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -402,6 +451,12 @@ func (i APIResourceArgs) ToAPIResourceOutputWithContext(ctx context.Context) API return pulumi.ToOutputWithContext(ctx, i).(APIResourceOutput) } +func (i APIResourceArgs) ToOutput(ctx context.Context) pulumix.Output[APIResource] { + return pulumix.Output[APIResource]{ + OutputState: i.ToAPIResourceOutputWithContext(ctx).OutputState, + } +} + // APIResourceArrayInput is an input type that accepts APIResourceArray and APIResourceArrayOutput values. // You can construct a concrete instance of `APIResourceArrayInput` via: // @@ -427,6 +482,12 @@ func (i APIResourceArray) ToAPIResourceArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(APIResourceArrayOutput) } +func (i APIResourceArray) ToOutput(ctx context.Context) pulumix.Output[[]APIResource] { + return pulumix.Output[[]APIResource]{ + OutputState: i.ToAPIResourceArrayOutputWithContext(ctx).OutputState, + } +} + // APIResource specifies the name of a resource and whether it is namespaced. type APIResourceOutput struct{ *pulumi.OutputState } @@ -442,6 +503,12 @@ func (o APIResourceOutput) ToAPIResourceOutputWithContext(ctx context.Context) A return o } +func (o APIResourceOutput) ToOutput(ctx context.Context) pulumix.Output[APIResource] { + return pulumix.Output[APIResource]{ + OutputState: o.OutputState, + } +} + // categories is a list of the grouped resources this resource belongs to (e.g. 'all') func (o APIResourceOutput) Categories() pulumi.StringArrayOutput { return o.ApplyT(func(v APIResource) []string { return v.Categories }).(pulumi.StringArrayOutput) @@ -506,6 +573,12 @@ func (o APIResourceArrayOutput) ToAPIResourceArrayOutputWithContext(ctx context. return o } +func (o APIResourceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIResource] { + return pulumix.Output[[]APIResource]{ + OutputState: o.OutputState, + } +} + func (o APIResourceArrayOutput) Index(i pulumi.IntInput) APIResourceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIResource { return vs[0].([]APIResource)[vs[1].(int)] @@ -559,6 +632,12 @@ func (i APIResourceListArgs) ToAPIResourceListOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(APIResourceListOutput) } +func (i APIResourceListArgs) ToOutput(ctx context.Context) pulumix.Output[APIResourceList] { + return pulumix.Output[APIResourceList]{ + OutputState: i.ToAPIResourceListOutputWithContext(ctx).OutputState, + } +} + // APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced. type APIResourceListOutput struct{ *pulumi.OutputState } @@ -574,6 +653,12 @@ func (o APIResourceListOutput) ToAPIResourceListOutputWithContext(ctx context.Co return o } +func (o APIResourceListOutput) ToOutput(ctx context.Context) pulumix.Output[APIResourceList] { + return pulumix.Output[APIResourceList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIResourceListOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIResourceList) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -665,6 +750,12 @@ func (i APIResourcePatchArgs) ToAPIResourcePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(APIResourcePatchOutput) } +func (i APIResourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIResourcePatch] { + return pulumix.Output[APIResourcePatch]{ + OutputState: i.ToAPIResourcePatchOutputWithContext(ctx).OutputState, + } +} + // APIResource specifies the name of a resource and whether it is namespaced. type APIResourcePatchOutput struct{ *pulumi.OutputState } @@ -680,6 +771,12 @@ func (o APIResourcePatchOutput) ToAPIResourcePatchOutputWithContext(ctx context. return o } +func (o APIResourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIResourcePatch] { + return pulumix.Output[APIResourcePatch]{ + OutputState: o.OutputState, + } +} + // categories is a list of the grouped resources this resource belongs to (e.g. 'all') func (o APIResourcePatchOutput) Categories() pulumi.StringArrayOutput { return o.ApplyT(func(v APIResourcePatch) []string { return v.Categories }).(pulumi.StringArrayOutput) @@ -777,6 +874,12 @@ func (i APIVersionsArgs) ToAPIVersionsOutputWithContext(ctx context.Context) API return pulumi.ToOutputWithContext(ctx, i).(APIVersionsOutput) } +func (i APIVersionsArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersions] { + return pulumix.Output[APIVersions]{ + OutputState: i.ToAPIVersionsOutputWithContext(ctx).OutputState, + } +} + // APIVersions lists the versions that are available, to allow clients to discover the API at /api, which is the root path of the legacy v1 API. type APIVersionsOutput struct{ *pulumi.OutputState } @@ -792,6 +895,12 @@ func (o APIVersionsOutput) ToAPIVersionsOutputWithContext(ctx context.Context) A return o } +func (o APIVersionsOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersions] { + return pulumix.Output[APIVersions]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIVersionsOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIVersions) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -859,6 +968,12 @@ func (i APIVersionsPatchArgs) ToAPIVersionsPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(APIVersionsPatchOutput) } +func (i APIVersionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionsPatch] { + return pulumix.Output[APIVersionsPatch]{ + OutputState: i.ToAPIVersionsPatchOutputWithContext(ctx).OutputState, + } +} + // APIVersions lists the versions that are available, to allow clients to discover the API at /api, which is the root path of the legacy v1 API. type APIVersionsPatchOutput struct{ *pulumi.OutputState } @@ -874,6 +989,12 @@ func (o APIVersionsPatchOutput) ToAPIVersionsPatchOutputWithContext(ctx context. return o } +func (o APIVersionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionsPatch] { + return pulumix.Output[APIVersionsPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o APIVersionsPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v APIVersionsPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -949,6 +1070,12 @@ func (i ConditionArgs) ToConditionOutputWithContext(ctx context.Context) Conditi return pulumi.ToOutputWithContext(ctx, i).(ConditionOutput) } +func (i ConditionArgs) ToOutput(ctx context.Context) pulumix.Output[Condition] { + return pulumix.Output[Condition]{ + OutputState: i.ToConditionOutputWithContext(ctx).OutputState, + } +} + // ConditionArrayInput is an input type that accepts ConditionArray and ConditionArrayOutput values. // You can construct a concrete instance of `ConditionArrayInput` via: // @@ -974,6 +1101,12 @@ func (i ConditionArray) ToConditionArrayOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ConditionArrayOutput) } +func (i ConditionArray) ToOutput(ctx context.Context) pulumix.Output[[]Condition] { + return pulumix.Output[[]Condition]{ + OutputState: i.ToConditionArrayOutputWithContext(ctx).OutputState, + } +} + // Condition contains details for one aspect of the current state of this API Resource. type ConditionOutput struct{ *pulumi.OutputState } @@ -989,6 +1122,12 @@ func (o ConditionOutput) ToConditionOutputWithContext(ctx context.Context) Condi return o } +func (o ConditionOutput) ToOutput(ctx context.Context) pulumix.Output[Condition] { + return pulumix.Output[Condition]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. func (o ConditionOutput) LastTransitionTime() pulumi.StringOutput { return o.ApplyT(func(v Condition) string { return v.LastTransitionTime }).(pulumi.StringOutput) @@ -1033,6 +1172,12 @@ func (o ConditionArrayOutput) ToConditionArrayOutputWithContext(ctx context.Cont return o } +func (o ConditionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Condition] { + return pulumix.Output[[]Condition]{ + OutputState: o.OutputState, + } +} + func (o ConditionArrayOutput) Index(i pulumi.IntInput) ConditionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Condition { return vs[0].([]Condition)[vs[1].(int)] @@ -1094,6 +1239,12 @@ func (i ConditionPatchArgs) ToConditionPatchOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ConditionPatchOutput) } +func (i ConditionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ConditionPatch] { + return pulumix.Output[ConditionPatch]{ + OutputState: i.ToConditionPatchOutputWithContext(ctx).OutputState, + } +} + // ConditionPatchArrayInput is an input type that accepts ConditionPatchArray and ConditionPatchArrayOutput values. // You can construct a concrete instance of `ConditionPatchArrayInput` via: // @@ -1119,6 +1270,12 @@ func (i ConditionPatchArray) ToConditionPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ConditionPatchArrayOutput) } +func (i ConditionPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ConditionPatch] { + return pulumix.Output[[]ConditionPatch]{ + OutputState: i.ToConditionPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Condition contains details for one aspect of the current state of this API Resource. type ConditionPatchOutput struct{ *pulumi.OutputState } @@ -1134,6 +1291,12 @@ func (o ConditionPatchOutput) ToConditionPatchOutputWithContext(ctx context.Cont return o } +func (o ConditionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ConditionPatch] { + return pulumix.Output[ConditionPatch]{ + OutputState: o.OutputState, + } +} + // lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. func (o ConditionPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { return o.ApplyT(func(v ConditionPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) @@ -1178,6 +1341,12 @@ func (o ConditionPatchArrayOutput) ToConditionPatchArrayOutputWithContext(ctx co return o } +func (o ConditionPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ConditionPatch] { + return pulumix.Output[[]ConditionPatch]{ + OutputState: o.OutputState, + } +} + func (o ConditionPatchArrayOutput) Index(i pulumi.IntInput) ConditionPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConditionPatch { return vs[0].([]ConditionPatch)[vs[1].(int)] @@ -1243,6 +1412,12 @@ func (i DeleteOptionsArgs) ToDeleteOptionsOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DeleteOptionsOutput) } +func (i DeleteOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[DeleteOptions] { + return pulumix.Output[DeleteOptions]{ + OutputState: i.ToDeleteOptionsOutputWithContext(ctx).OutputState, + } +} + func (i DeleteOptionsArgs) ToDeleteOptionsPtrOutput() DeleteOptionsPtrOutput { return i.ToDeleteOptionsPtrOutputWithContext(context.Background()) } @@ -1284,6 +1459,12 @@ func (i *deleteOptionsPtrType) ToDeleteOptionsPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(DeleteOptionsPtrOutput) } +func (i *deleteOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeleteOptions] { + return pulumix.Output[*DeleteOptions]{ + OutputState: i.ToDeleteOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // DeleteOptions may be provided when deleting an API object. type DeleteOptionsOutput struct{ *pulumi.OutputState } @@ -1309,6 +1490,12 @@ func (o DeleteOptionsOutput) ToDeleteOptionsPtrOutputWithContext(ctx context.Con }).(DeleteOptionsPtrOutput) } +func (o DeleteOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[DeleteOptions] { + return pulumix.Output[DeleteOptions]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeleteOptionsOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeleteOptions) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1358,6 +1545,12 @@ func (o DeleteOptionsPtrOutput) ToDeleteOptionsPtrOutputWithContext(ctx context. return o } +func (o DeleteOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeleteOptions] { + return pulumix.Output[*DeleteOptions]{ + OutputState: o.OutputState, + } +} + func (o DeleteOptionsPtrOutput) Elem() DeleteOptionsOutput { return o.ApplyT(func(v *DeleteOptions) DeleteOptions { if v != nil { @@ -1497,6 +1690,12 @@ func (i DeleteOptionsPatchArgs) ToDeleteOptionsPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(DeleteOptionsPatchOutput) } +func (i DeleteOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[DeleteOptionsPatch] { + return pulumix.Output[DeleteOptionsPatch]{ + OutputState: i.ToDeleteOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i DeleteOptionsPatchArgs) ToDeleteOptionsPatchPtrOutput() DeleteOptionsPatchPtrOutput { return i.ToDeleteOptionsPatchPtrOutputWithContext(context.Background()) } @@ -1538,6 +1737,12 @@ func (i *deleteOptionsPatchPtrType) ToDeleteOptionsPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(DeleteOptionsPatchPtrOutput) } +func (i *deleteOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*DeleteOptionsPatch] { + return pulumix.Output[*DeleteOptionsPatch]{ + OutputState: i.ToDeleteOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // DeleteOptions may be provided when deleting an API object. type DeleteOptionsPatchOutput struct{ *pulumi.OutputState } @@ -1563,6 +1768,12 @@ func (o DeleteOptionsPatchOutput) ToDeleteOptionsPatchPtrOutputWithContext(ctx c }).(DeleteOptionsPatchPtrOutput) } +func (o DeleteOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[DeleteOptionsPatch] { + return pulumix.Output[DeleteOptionsPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o DeleteOptionsPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v DeleteOptionsPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1612,6 +1823,12 @@ func (o DeleteOptionsPatchPtrOutput) ToDeleteOptionsPatchPtrOutputWithContext(ct return o } +func (o DeleteOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DeleteOptionsPatch] { + return pulumix.Output[*DeleteOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o DeleteOptionsPatchPtrOutput) Elem() DeleteOptionsPatchOutput { return o.ApplyT(func(v *DeleteOptionsPatch) DeleteOptionsPatch { if v != nil { @@ -1731,6 +1948,12 @@ func (i GroupVersionForDiscoveryArgs) ToGroupVersionForDiscoveryOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(GroupVersionForDiscoveryOutput) } +func (i GroupVersionForDiscoveryArgs) ToOutput(ctx context.Context) pulumix.Output[GroupVersionForDiscovery] { + return pulumix.Output[GroupVersionForDiscovery]{ + OutputState: i.ToGroupVersionForDiscoveryOutputWithContext(ctx).OutputState, + } +} + func (i GroupVersionForDiscoveryArgs) ToGroupVersionForDiscoveryPtrOutput() GroupVersionForDiscoveryPtrOutput { return i.ToGroupVersionForDiscoveryPtrOutputWithContext(context.Background()) } @@ -1772,6 +1995,12 @@ func (i *groupVersionForDiscoveryPtrType) ToGroupVersionForDiscoveryPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(GroupVersionForDiscoveryPtrOutput) } +func (i *groupVersionForDiscoveryPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupVersionForDiscovery] { + return pulumix.Output[*GroupVersionForDiscovery]{ + OutputState: i.ToGroupVersionForDiscoveryPtrOutputWithContext(ctx).OutputState, + } +} + // GroupVersionForDiscoveryArrayInput is an input type that accepts GroupVersionForDiscoveryArray and GroupVersionForDiscoveryArrayOutput values. // You can construct a concrete instance of `GroupVersionForDiscoveryArrayInput` via: // @@ -1797,6 +2026,12 @@ func (i GroupVersionForDiscoveryArray) ToGroupVersionForDiscoveryArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(GroupVersionForDiscoveryArrayOutput) } +func (i GroupVersionForDiscoveryArray) ToOutput(ctx context.Context) pulumix.Output[[]GroupVersionForDiscovery] { + return pulumix.Output[[]GroupVersionForDiscovery]{ + OutputState: i.ToGroupVersionForDiscoveryArrayOutputWithContext(ctx).OutputState, + } +} + // GroupVersion contains the "group/version" and "version" string of a version. It is made a struct to keep extensibility. type GroupVersionForDiscoveryOutput struct{ *pulumi.OutputState } @@ -1822,6 +2057,12 @@ func (o GroupVersionForDiscoveryOutput) ToGroupVersionForDiscoveryPtrOutputWithC }).(GroupVersionForDiscoveryPtrOutput) } +func (o GroupVersionForDiscoveryOutput) ToOutput(ctx context.Context) pulumix.Output[GroupVersionForDiscovery] { + return pulumix.Output[GroupVersionForDiscovery]{ + OutputState: o.OutputState, + } +} + // groupVersion specifies the API group and version in the form "group/version" func (o GroupVersionForDiscoveryOutput) GroupVersion() pulumi.StringOutput { return o.ApplyT(func(v GroupVersionForDiscovery) string { return v.GroupVersion }).(pulumi.StringOutput) @@ -1846,6 +2087,12 @@ func (o GroupVersionForDiscoveryPtrOutput) ToGroupVersionForDiscoveryPtrOutputWi return o } +func (o GroupVersionForDiscoveryPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupVersionForDiscovery] { + return pulumix.Output[*GroupVersionForDiscovery]{ + OutputState: o.OutputState, + } +} + func (o GroupVersionForDiscoveryPtrOutput) Elem() GroupVersionForDiscoveryOutput { return o.ApplyT(func(v *GroupVersionForDiscovery) GroupVersionForDiscovery { if v != nil { @@ -1890,6 +2137,12 @@ func (o GroupVersionForDiscoveryArrayOutput) ToGroupVersionForDiscoveryArrayOutp return o } +func (o GroupVersionForDiscoveryArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GroupVersionForDiscovery] { + return pulumix.Output[[]GroupVersionForDiscovery]{ + OutputState: o.OutputState, + } +} + func (o GroupVersionForDiscoveryArrayOutput) Index(i pulumi.IntInput) GroupVersionForDiscoveryOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) GroupVersionForDiscovery { return vs[0].([]GroupVersionForDiscovery)[vs[1].(int)] @@ -1935,6 +2188,12 @@ func (i GroupVersionForDiscoveryPatchArgs) ToGroupVersionForDiscoveryPatchOutput return pulumi.ToOutputWithContext(ctx, i).(GroupVersionForDiscoveryPatchOutput) } +func (i GroupVersionForDiscoveryPatchArgs) ToOutput(ctx context.Context) pulumix.Output[GroupVersionForDiscoveryPatch] { + return pulumix.Output[GroupVersionForDiscoveryPatch]{ + OutputState: i.ToGroupVersionForDiscoveryPatchOutputWithContext(ctx).OutputState, + } +} + func (i GroupVersionForDiscoveryPatchArgs) ToGroupVersionForDiscoveryPatchPtrOutput() GroupVersionForDiscoveryPatchPtrOutput { return i.ToGroupVersionForDiscoveryPatchPtrOutputWithContext(context.Background()) } @@ -1976,6 +2235,12 @@ func (i *groupVersionForDiscoveryPatchPtrType) ToGroupVersionForDiscoveryPatchPt return pulumi.ToOutputWithContext(ctx, i).(GroupVersionForDiscoveryPatchPtrOutput) } +func (i *groupVersionForDiscoveryPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GroupVersionForDiscoveryPatch] { + return pulumix.Output[*GroupVersionForDiscoveryPatch]{ + OutputState: i.ToGroupVersionForDiscoveryPatchPtrOutputWithContext(ctx).OutputState, + } +} + // GroupVersionForDiscoveryPatchArrayInput is an input type that accepts GroupVersionForDiscoveryPatchArray and GroupVersionForDiscoveryPatchArrayOutput values. // You can construct a concrete instance of `GroupVersionForDiscoveryPatchArrayInput` via: // @@ -2001,6 +2266,12 @@ func (i GroupVersionForDiscoveryPatchArray) ToGroupVersionForDiscoveryPatchArray return pulumi.ToOutputWithContext(ctx, i).(GroupVersionForDiscoveryPatchArrayOutput) } +func (i GroupVersionForDiscoveryPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]GroupVersionForDiscoveryPatch] { + return pulumix.Output[[]GroupVersionForDiscoveryPatch]{ + OutputState: i.ToGroupVersionForDiscoveryPatchArrayOutputWithContext(ctx).OutputState, + } +} + // GroupVersion contains the "group/version" and "version" string of a version. It is made a struct to keep extensibility. type GroupVersionForDiscoveryPatchOutput struct{ *pulumi.OutputState } @@ -2026,6 +2297,12 @@ func (o GroupVersionForDiscoveryPatchOutput) ToGroupVersionForDiscoveryPatchPtrO }).(GroupVersionForDiscoveryPatchPtrOutput) } +func (o GroupVersionForDiscoveryPatchOutput) ToOutput(ctx context.Context) pulumix.Output[GroupVersionForDiscoveryPatch] { + return pulumix.Output[GroupVersionForDiscoveryPatch]{ + OutputState: o.OutputState, + } +} + // groupVersion specifies the API group and version in the form "group/version" func (o GroupVersionForDiscoveryPatchOutput) GroupVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v GroupVersionForDiscoveryPatch) *string { return v.GroupVersion }).(pulumi.StringPtrOutput) @@ -2050,6 +2327,12 @@ func (o GroupVersionForDiscoveryPatchPtrOutput) ToGroupVersionForDiscoveryPatchP return o } +func (o GroupVersionForDiscoveryPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GroupVersionForDiscoveryPatch] { + return pulumix.Output[*GroupVersionForDiscoveryPatch]{ + OutputState: o.OutputState, + } +} + func (o GroupVersionForDiscoveryPatchPtrOutput) Elem() GroupVersionForDiscoveryPatchOutput { return o.ApplyT(func(v *GroupVersionForDiscoveryPatch) GroupVersionForDiscoveryPatch { if v != nil { @@ -2094,6 +2377,12 @@ func (o GroupVersionForDiscoveryPatchArrayOutput) ToGroupVersionForDiscoveryPatc return o } +func (o GroupVersionForDiscoveryPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GroupVersionForDiscoveryPatch] { + return pulumix.Output[[]GroupVersionForDiscoveryPatch]{ + OutputState: o.OutputState, + } +} + func (o GroupVersionForDiscoveryPatchArrayOutput) Index(i pulumi.IntInput) GroupVersionForDiscoveryPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) GroupVersionForDiscoveryPatch { return vs[0].([]GroupVersionForDiscoveryPatch)[vs[1].(int)] @@ -2139,6 +2428,12 @@ func (i LabelSelectorArgs) ToLabelSelectorOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorOutput) } +func (i LabelSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[LabelSelector] { + return pulumix.Output[LabelSelector]{ + OutputState: i.ToLabelSelectorOutputWithContext(ctx).OutputState, + } +} + func (i LabelSelectorArgs) ToLabelSelectorPtrOutput() LabelSelectorPtrOutput { return i.ToLabelSelectorPtrOutputWithContext(context.Background()) } @@ -2180,6 +2475,12 @@ func (i *labelSelectorPtrType) ToLabelSelectorPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorPtrOutput) } +func (i *labelSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*LabelSelector] { + return pulumix.Output[*LabelSelector]{ + OutputState: i.ToLabelSelectorPtrOutputWithContext(ctx).OutputState, + } +} + // LabelSelectorArrayInput is an input type that accepts LabelSelectorArray and LabelSelectorArrayOutput values. // You can construct a concrete instance of `LabelSelectorArrayInput` via: // @@ -2205,6 +2506,12 @@ func (i LabelSelectorArray) ToLabelSelectorArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArrayOutput) } +func (i LabelSelectorArray) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelector] { + return pulumix.Output[[]LabelSelector]{ + OutputState: i.ToLabelSelectorArrayOutputWithContext(ctx).OutputState, + } +} + // A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. type LabelSelectorOutput struct{ *pulumi.OutputState } @@ -2230,6 +2537,12 @@ func (o LabelSelectorOutput) ToLabelSelectorPtrOutputWithContext(ctx context.Con }).(LabelSelectorPtrOutput) } +func (o LabelSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[LabelSelector] { + return pulumix.Output[LabelSelector]{ + OutputState: o.OutputState, + } +} + // matchExpressions is a list of label selector requirements. The requirements are ANDed. func (o LabelSelectorOutput) MatchExpressions() LabelSelectorRequirementArrayOutput { return o.ApplyT(func(v LabelSelector) []LabelSelectorRequirement { return v.MatchExpressions }).(LabelSelectorRequirementArrayOutput) @@ -2254,6 +2567,12 @@ func (o LabelSelectorPtrOutput) ToLabelSelectorPtrOutputWithContext(ctx context. return o } +func (o LabelSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LabelSelector] { + return pulumix.Output[*LabelSelector]{ + OutputState: o.OutputState, + } +} + func (o LabelSelectorPtrOutput) Elem() LabelSelectorOutput { return o.ApplyT(func(v *LabelSelector) LabelSelector { if v != nil { @@ -2298,6 +2617,12 @@ func (o LabelSelectorArrayOutput) ToLabelSelectorArrayOutputWithContext(ctx cont return o } +func (o LabelSelectorArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelector] { + return pulumix.Output[[]LabelSelector]{ + OutputState: o.OutputState, + } +} + func (o LabelSelectorArrayOutput) Index(i pulumi.IntInput) LabelSelectorOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LabelSelector { return vs[0].([]LabelSelector)[vs[1].(int)] @@ -2343,6 +2668,12 @@ func (i LabelSelectorPatchArgs) ToLabelSelectorPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorPatchOutput) } +func (i LabelSelectorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LabelSelectorPatch] { + return pulumix.Output[LabelSelectorPatch]{ + OutputState: i.ToLabelSelectorPatchOutputWithContext(ctx).OutputState, + } +} + func (i LabelSelectorPatchArgs) ToLabelSelectorPatchPtrOutput() LabelSelectorPatchPtrOutput { return i.ToLabelSelectorPatchPtrOutputWithContext(context.Background()) } @@ -2384,6 +2715,12 @@ func (i *labelSelectorPatchPtrType) ToLabelSelectorPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorPatchPtrOutput) } +func (i *labelSelectorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*LabelSelectorPatch] { + return pulumix.Output[*LabelSelectorPatch]{ + OutputState: i.ToLabelSelectorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // LabelSelectorPatchArrayInput is an input type that accepts LabelSelectorPatchArray and LabelSelectorPatchArrayOutput values. // You can construct a concrete instance of `LabelSelectorPatchArrayInput` via: // @@ -2409,6 +2746,12 @@ func (i LabelSelectorPatchArray) ToLabelSelectorPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorPatchArrayOutput) } +func (i LabelSelectorPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelectorPatch] { + return pulumix.Output[[]LabelSelectorPatch]{ + OutputState: i.ToLabelSelectorPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. type LabelSelectorPatchOutput struct{ *pulumi.OutputState } @@ -2434,6 +2777,12 @@ func (o LabelSelectorPatchOutput) ToLabelSelectorPatchPtrOutputWithContext(ctx c }).(LabelSelectorPatchPtrOutput) } +func (o LabelSelectorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LabelSelectorPatch] { + return pulumix.Output[LabelSelectorPatch]{ + OutputState: o.OutputState, + } +} + // matchExpressions is a list of label selector requirements. The requirements are ANDed. func (o LabelSelectorPatchOutput) MatchExpressions() LabelSelectorRequirementPatchArrayOutput { return o.ApplyT(func(v LabelSelectorPatch) []LabelSelectorRequirementPatch { return v.MatchExpressions }).(LabelSelectorRequirementPatchArrayOutput) @@ -2458,6 +2807,12 @@ func (o LabelSelectorPatchPtrOutput) ToLabelSelectorPatchPtrOutputWithContext(ct return o } +func (o LabelSelectorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*LabelSelectorPatch] { + return pulumix.Output[*LabelSelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o LabelSelectorPatchPtrOutput) Elem() LabelSelectorPatchOutput { return o.ApplyT(func(v *LabelSelectorPatch) LabelSelectorPatch { if v != nil { @@ -2502,6 +2857,12 @@ func (o LabelSelectorPatchArrayOutput) ToLabelSelectorPatchArrayOutputWithContex return o } +func (o LabelSelectorPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelectorPatch] { + return pulumix.Output[[]LabelSelectorPatch]{ + OutputState: o.OutputState, + } +} + func (o LabelSelectorPatchArrayOutput) Index(i pulumi.IntInput) LabelSelectorPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LabelSelectorPatch { return vs[0].([]LabelSelectorPatch)[vs[1].(int)] @@ -2551,6 +2912,12 @@ func (i LabelSelectorRequirementArgs) ToLabelSelectorRequirementOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementOutput) } +func (i LabelSelectorRequirementArgs) ToOutput(ctx context.Context) pulumix.Output[LabelSelectorRequirement] { + return pulumix.Output[LabelSelectorRequirement]{ + OutputState: i.ToLabelSelectorRequirementOutputWithContext(ctx).OutputState, + } +} + // LabelSelectorRequirementArrayInput is an input type that accepts LabelSelectorRequirementArray and LabelSelectorRequirementArrayOutput values. // You can construct a concrete instance of `LabelSelectorRequirementArrayInput` via: // @@ -2576,6 +2943,12 @@ func (i LabelSelectorRequirementArray) ToLabelSelectorRequirementArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementArrayOutput) } +func (i LabelSelectorRequirementArray) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelectorRequirement] { + return pulumix.Output[[]LabelSelectorRequirement]{ + OutputState: i.ToLabelSelectorRequirementArrayOutputWithContext(ctx).OutputState, + } +} + // A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. type LabelSelectorRequirementOutput struct{ *pulumi.OutputState } @@ -2591,6 +2964,12 @@ func (o LabelSelectorRequirementOutput) ToLabelSelectorRequirementOutputWithCont return o } +func (o LabelSelectorRequirementOutput) ToOutput(ctx context.Context) pulumix.Output[LabelSelectorRequirement] { + return pulumix.Output[LabelSelectorRequirement]{ + OutputState: o.OutputState, + } +} + // key is the label key that the selector applies to. func (o LabelSelectorRequirementOutput) Key() pulumi.StringOutput { return o.ApplyT(func(v LabelSelectorRequirement) string { return v.Key }).(pulumi.StringOutput) @@ -2620,6 +2999,12 @@ func (o LabelSelectorRequirementArrayOutput) ToLabelSelectorRequirementArrayOutp return o } +func (o LabelSelectorRequirementArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelectorRequirement] { + return pulumix.Output[[]LabelSelectorRequirement]{ + OutputState: o.OutputState, + } +} + func (o LabelSelectorRequirementArrayOutput) Index(i pulumi.IntInput) LabelSelectorRequirementOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LabelSelectorRequirement { return vs[0].([]LabelSelectorRequirement)[vs[1].(int)] @@ -2669,6 +3054,12 @@ func (i LabelSelectorRequirementPatchArgs) ToLabelSelectorRequirementPatchOutput return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementPatchOutput) } +func (i LabelSelectorRequirementPatchArgs) ToOutput(ctx context.Context) pulumix.Output[LabelSelectorRequirementPatch] { + return pulumix.Output[LabelSelectorRequirementPatch]{ + OutputState: i.ToLabelSelectorRequirementPatchOutputWithContext(ctx).OutputState, + } +} + // LabelSelectorRequirementPatchArrayInput is an input type that accepts LabelSelectorRequirementPatchArray and LabelSelectorRequirementPatchArrayOutput values. // You can construct a concrete instance of `LabelSelectorRequirementPatchArrayInput` via: // @@ -2694,6 +3085,12 @@ func (i LabelSelectorRequirementPatchArray) ToLabelSelectorRequirementPatchArray return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementPatchArrayOutput) } +func (i LabelSelectorRequirementPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelectorRequirementPatch] { + return pulumix.Output[[]LabelSelectorRequirementPatch]{ + OutputState: i.ToLabelSelectorRequirementPatchArrayOutputWithContext(ctx).OutputState, + } +} + // A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. type LabelSelectorRequirementPatchOutput struct{ *pulumi.OutputState } @@ -2709,6 +3106,12 @@ func (o LabelSelectorRequirementPatchOutput) ToLabelSelectorRequirementPatchOutp return o } +func (o LabelSelectorRequirementPatchOutput) ToOutput(ctx context.Context) pulumix.Output[LabelSelectorRequirementPatch] { + return pulumix.Output[LabelSelectorRequirementPatch]{ + OutputState: o.OutputState, + } +} + // key is the label key that the selector applies to. func (o LabelSelectorRequirementPatchOutput) Key() pulumi.StringPtrOutput { return o.ApplyT(func(v LabelSelectorRequirementPatch) *string { return v.Key }).(pulumi.StringPtrOutput) @@ -2738,6 +3141,12 @@ func (o LabelSelectorRequirementPatchArrayOutput) ToLabelSelectorRequirementPatc return o } +func (o LabelSelectorRequirementPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]LabelSelectorRequirementPatch] { + return pulumix.Output[[]LabelSelectorRequirementPatch]{ + OutputState: o.OutputState, + } +} + func (o LabelSelectorRequirementPatchArrayOutput) Index(i pulumi.IntInput) LabelSelectorRequirementPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) LabelSelectorRequirementPatch { return vs[0].([]LabelSelectorRequirementPatch)[vs[1].(int)] @@ -2791,6 +3200,12 @@ func (i ListMetaArgs) ToListMetaOutputWithContext(ctx context.Context) ListMetaO return pulumi.ToOutputWithContext(ctx, i).(ListMetaOutput) } +func (i ListMetaArgs) ToOutput(ctx context.Context) pulumix.Output[ListMeta] { + return pulumix.Output[ListMeta]{ + OutputState: i.ToListMetaOutputWithContext(ctx).OutputState, + } +} + func (i ListMetaArgs) ToListMetaPtrOutput() ListMetaPtrOutput { return i.ToListMetaPtrOutputWithContext(context.Background()) } @@ -2832,6 +3247,12 @@ func (i *listMetaPtrType) ToListMetaPtrOutputWithContext(ctx context.Context) Li return pulumi.ToOutputWithContext(ctx, i).(ListMetaPtrOutput) } +func (i *listMetaPtrType) ToOutput(ctx context.Context) pulumix.Output[*ListMeta] { + return pulumix.Output[*ListMeta]{ + OutputState: i.ToListMetaPtrOutputWithContext(ctx).OutputState, + } +} + // ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. type ListMetaOutput struct{ *pulumi.OutputState } @@ -2857,6 +3278,12 @@ func (o ListMetaOutput) ToListMetaPtrOutputWithContext(ctx context.Context) List }).(ListMetaPtrOutput) } +func (o ListMetaOutput) ToOutput(ctx context.Context) pulumix.Output[ListMeta] { + return pulumix.Output[ListMeta]{ + OutputState: o.OutputState, + } +} + // continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message. func (o ListMetaOutput) Continue() pulumi.StringPtrOutput { return o.ApplyT(func(v ListMeta) *string { return v.Continue }).(pulumi.StringPtrOutput) @@ -2891,6 +3318,12 @@ func (o ListMetaPtrOutput) ToListMetaPtrOutputWithContext(ctx context.Context) L return o } +func (o ListMetaPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ListMeta] { + return pulumix.Output[*ListMeta]{ + OutputState: o.OutputState, + } +} + func (o ListMetaPtrOutput) Elem() ListMetaOutput { return o.ApplyT(func(v *ListMeta) ListMeta { if v != nil { @@ -2988,6 +3421,12 @@ func (i ListMetaPatchArgs) ToListMetaPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(ListMetaPatchOutput) } +func (i ListMetaPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ListMetaPatch] { + return pulumix.Output[ListMetaPatch]{ + OutputState: i.ToListMetaPatchOutputWithContext(ctx).OutputState, + } +} + func (i ListMetaPatchArgs) ToListMetaPatchPtrOutput() ListMetaPatchPtrOutput { return i.ToListMetaPatchPtrOutputWithContext(context.Background()) } @@ -3029,6 +3468,12 @@ func (i *listMetaPatchPtrType) ToListMetaPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ListMetaPatchPtrOutput) } +func (i *listMetaPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ListMetaPatch] { + return pulumix.Output[*ListMetaPatch]{ + OutputState: i.ToListMetaPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. type ListMetaPatchOutput struct{ *pulumi.OutputState } @@ -3054,6 +3499,12 @@ func (o ListMetaPatchOutput) ToListMetaPatchPtrOutputWithContext(ctx context.Con }).(ListMetaPatchPtrOutput) } +func (o ListMetaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ListMetaPatch] { + return pulumix.Output[ListMetaPatch]{ + OutputState: o.OutputState, + } +} + // continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message. func (o ListMetaPatchOutput) Continue() pulumi.StringPtrOutput { return o.ApplyT(func(v ListMetaPatch) *string { return v.Continue }).(pulumi.StringPtrOutput) @@ -3088,6 +3539,12 @@ func (o ListMetaPatchPtrOutput) ToListMetaPatchPtrOutputWithContext(ctx context. return o } +func (o ListMetaPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ListMetaPatch] { + return pulumix.Output[*ListMetaPatch]{ + OutputState: o.OutputState, + } +} + func (o ListMetaPatchPtrOutput) Elem() ListMetaPatchOutput { return o.ApplyT(func(v *ListMetaPatch) ListMetaPatch { if v != nil { @@ -3197,6 +3654,12 @@ func (i ManagedFieldsEntryArgs) ToManagedFieldsEntryOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ManagedFieldsEntryOutput) } +func (i ManagedFieldsEntryArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedFieldsEntry] { + return pulumix.Output[ManagedFieldsEntry]{ + OutputState: i.ToManagedFieldsEntryOutputWithContext(ctx).OutputState, + } +} + // ManagedFieldsEntryArrayInput is an input type that accepts ManagedFieldsEntryArray and ManagedFieldsEntryArrayOutput values. // You can construct a concrete instance of `ManagedFieldsEntryArrayInput` via: // @@ -3222,6 +3685,12 @@ func (i ManagedFieldsEntryArray) ToManagedFieldsEntryArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ManagedFieldsEntryArrayOutput) } +func (i ManagedFieldsEntryArray) ToOutput(ctx context.Context) pulumix.Output[[]ManagedFieldsEntry] { + return pulumix.Output[[]ManagedFieldsEntry]{ + OutputState: i.ToManagedFieldsEntryArrayOutputWithContext(ctx).OutputState, + } +} + // ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to. type ManagedFieldsEntryOutput struct{ *pulumi.OutputState } @@ -3237,6 +3706,12 @@ func (o ManagedFieldsEntryOutput) ToManagedFieldsEntryOutputWithContext(ctx cont return o } +func (o ManagedFieldsEntryOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedFieldsEntry] { + return pulumix.Output[ManagedFieldsEntry]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the version of this resource that this field set applies to. The format is "group/version" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted. func (o ManagedFieldsEntryOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ManagedFieldsEntry) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3286,6 +3761,12 @@ func (o ManagedFieldsEntryArrayOutput) ToManagedFieldsEntryArrayOutputWithContex return o } +func (o ManagedFieldsEntryArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ManagedFieldsEntry] { + return pulumix.Output[[]ManagedFieldsEntry]{ + OutputState: o.OutputState, + } +} + func (o ManagedFieldsEntryArrayOutput) Index(i pulumi.IntInput) ManagedFieldsEntryOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ManagedFieldsEntry { return vs[0].([]ManagedFieldsEntry)[vs[1].(int)] @@ -3351,6 +3832,12 @@ func (i ManagedFieldsEntryPatchArgs) ToManagedFieldsEntryPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ManagedFieldsEntryPatchOutput) } +func (i ManagedFieldsEntryPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedFieldsEntryPatch] { + return pulumix.Output[ManagedFieldsEntryPatch]{ + OutputState: i.ToManagedFieldsEntryPatchOutputWithContext(ctx).OutputState, + } +} + // ManagedFieldsEntryPatchArrayInput is an input type that accepts ManagedFieldsEntryPatchArray and ManagedFieldsEntryPatchArrayOutput values. // You can construct a concrete instance of `ManagedFieldsEntryPatchArrayInput` via: // @@ -3376,6 +3863,12 @@ func (i ManagedFieldsEntryPatchArray) ToManagedFieldsEntryPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ManagedFieldsEntryPatchArrayOutput) } +func (i ManagedFieldsEntryPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ManagedFieldsEntryPatch] { + return pulumix.Output[[]ManagedFieldsEntryPatch]{ + OutputState: i.ToManagedFieldsEntryPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to. type ManagedFieldsEntryPatchOutput struct{ *pulumi.OutputState } @@ -3391,6 +3884,12 @@ func (o ManagedFieldsEntryPatchOutput) ToManagedFieldsEntryPatchOutputWithContex return o } +func (o ManagedFieldsEntryPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedFieldsEntryPatch] { + return pulumix.Output[ManagedFieldsEntryPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the version of this resource that this field set applies to. The format is "group/version" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted. func (o ManagedFieldsEntryPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ManagedFieldsEntryPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3440,6 +3939,12 @@ func (o ManagedFieldsEntryPatchArrayOutput) ToManagedFieldsEntryPatchArrayOutput return o } +func (o ManagedFieldsEntryPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ManagedFieldsEntryPatch] { + return pulumix.Output[[]ManagedFieldsEntryPatch]{ + OutputState: o.OutputState, + } +} + func (o ManagedFieldsEntryPatchArrayOutput) Index(i pulumi.IntInput) ManagedFieldsEntryPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ManagedFieldsEntryPatch { return vs[0].([]ManagedFieldsEntryPatch)[vs[1].(int)] @@ -3569,6 +4074,12 @@ func (i ObjectMetaArgs) ToObjectMetaOutputWithContext(ctx context.Context) Objec return pulumi.ToOutputWithContext(ctx, i).(ObjectMetaOutput) } +func (i ObjectMetaArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMeta] { + return pulumix.Output[ObjectMeta]{ + OutputState: i.ToObjectMetaOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetaArgs) ToObjectMetaPtrOutput() ObjectMetaPtrOutput { return i.ToObjectMetaPtrOutputWithContext(context.Background()) } @@ -3610,6 +4121,12 @@ func (i *objectMetaPtrType) ToObjectMetaPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ObjectMetaPtrOutput) } +func (i *objectMetaPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMeta] { + return pulumix.Output[*ObjectMeta]{ + OutputState: i.ToObjectMetaPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. type ObjectMetaOutput struct{ *pulumi.OutputState } @@ -3635,6 +4152,12 @@ func (o ObjectMetaOutput) ToObjectMetaPtrOutputWithContext(ctx context.Context) }).(ObjectMetaPtrOutput) } +func (o ObjectMetaOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMeta] { + return pulumix.Output[ObjectMeta]{ + OutputState: o.OutputState, + } +} + // Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations func (o ObjectMetaOutput) Annotations() pulumi.StringMapOutput { return o.ApplyT(func(v ObjectMeta) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) @@ -3743,6 +4266,12 @@ func (o ObjectMetaPtrOutput) ToObjectMetaPtrOutputWithContext(ctx context.Contex return o } +func (o ObjectMetaPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMeta] { + return pulumix.Output[*ObjectMeta]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetaPtrOutput) Elem() ObjectMetaOutput { return o.ApplyT(func(v *ObjectMeta) ObjectMeta { if v != nil { @@ -4050,6 +4579,12 @@ func (i ObjectMetaPatchArgs) ToObjectMetaPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ObjectMetaPatchOutput) } +func (i ObjectMetaPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ObjectMetaPatch] { + return pulumix.Output[ObjectMetaPatch]{ + OutputState: i.ToObjectMetaPatchOutputWithContext(ctx).OutputState, + } +} + func (i ObjectMetaPatchArgs) ToObjectMetaPatchPtrOutput() ObjectMetaPatchPtrOutput { return i.ToObjectMetaPatchPtrOutputWithContext(context.Background()) } @@ -4091,6 +4626,12 @@ func (i *objectMetaPatchPtrType) ToObjectMetaPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(ObjectMetaPatchPtrOutput) } +func (i *objectMetaPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetaPatch] { + return pulumix.Output[*ObjectMetaPatch]{ + OutputState: i.ToObjectMetaPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. type ObjectMetaPatchOutput struct{ *pulumi.OutputState } @@ -4116,6 +4657,12 @@ func (o ObjectMetaPatchOutput) ToObjectMetaPatchPtrOutputWithContext(ctx context }).(ObjectMetaPatchPtrOutput) } +func (o ObjectMetaPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ObjectMetaPatch] { + return pulumix.Output[ObjectMetaPatch]{ + OutputState: o.OutputState, + } +} + // Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations func (o ObjectMetaPatchOutput) Annotations() pulumi.StringMapOutput { return o.ApplyT(func(v ObjectMetaPatch) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) @@ -4224,6 +4771,12 @@ func (o ObjectMetaPatchPtrOutput) ToObjectMetaPatchPtrOutputWithContext(ctx cont return o } +func (o ObjectMetaPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ObjectMetaPatch] { + return pulumix.Output[*ObjectMetaPatch]{ + OutputState: o.OutputState, + } +} + func (o ObjectMetaPatchPtrOutput) Elem() ObjectMetaPatchOutput { return o.ApplyT(func(v *ObjectMetaPatch) ObjectMetaPatch { if v != nil { @@ -4463,6 +5016,12 @@ func (i OwnerReferenceArgs) ToOwnerReferenceOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(OwnerReferenceOutput) } +func (i OwnerReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[OwnerReference] { + return pulumix.Output[OwnerReference]{ + OutputState: i.ToOwnerReferenceOutputWithContext(ctx).OutputState, + } +} + // OwnerReferenceArrayInput is an input type that accepts OwnerReferenceArray and OwnerReferenceArrayOutput values. // You can construct a concrete instance of `OwnerReferenceArrayInput` via: // @@ -4488,6 +5047,12 @@ func (i OwnerReferenceArray) ToOwnerReferenceArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(OwnerReferenceArrayOutput) } +func (i OwnerReferenceArray) ToOutput(ctx context.Context) pulumix.Output[[]OwnerReference] { + return pulumix.Output[[]OwnerReference]{ + OutputState: i.ToOwnerReferenceArrayOutputWithContext(ctx).OutputState, + } +} + // OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. type OwnerReferenceOutput struct{ *pulumi.OutputState } @@ -4503,6 +5068,12 @@ func (o OwnerReferenceOutput) ToOwnerReferenceOutputWithContext(ctx context.Cont return o } +func (o OwnerReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[OwnerReference] { + return pulumix.Output[OwnerReference]{ + OutputState: o.OutputState, + } +} + // API version of the referent. func (o OwnerReferenceOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v OwnerReference) string { return v.ApiVersion }).(pulumi.StringOutput) @@ -4547,6 +5118,12 @@ func (o OwnerReferenceArrayOutput) ToOwnerReferenceArrayOutputWithContext(ctx co return o } +func (o OwnerReferenceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]OwnerReference] { + return pulumix.Output[[]OwnerReference]{ + OutputState: o.OutputState, + } +} + func (o OwnerReferenceArrayOutput) Index(i pulumi.IntInput) OwnerReferenceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) OwnerReference { return vs[0].([]OwnerReference)[vs[1].(int)] @@ -4608,6 +5185,12 @@ func (i OwnerReferencePatchArgs) ToOwnerReferencePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(OwnerReferencePatchOutput) } +func (i OwnerReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[OwnerReferencePatch] { + return pulumix.Output[OwnerReferencePatch]{ + OutputState: i.ToOwnerReferencePatchOutputWithContext(ctx).OutputState, + } +} + // OwnerReferencePatchArrayInput is an input type that accepts OwnerReferencePatchArray and OwnerReferencePatchArrayOutput values. // You can construct a concrete instance of `OwnerReferencePatchArrayInput` via: // @@ -4633,6 +5216,12 @@ func (i OwnerReferencePatchArray) ToOwnerReferencePatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(OwnerReferencePatchArrayOutput) } +func (i OwnerReferencePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]OwnerReferencePatch] { + return pulumix.Output[[]OwnerReferencePatch]{ + OutputState: i.ToOwnerReferencePatchArrayOutputWithContext(ctx).OutputState, + } +} + // OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. type OwnerReferencePatchOutput struct{ *pulumi.OutputState } @@ -4648,6 +5237,12 @@ func (o OwnerReferencePatchOutput) ToOwnerReferencePatchOutputWithContext(ctx co return o } +func (o OwnerReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[OwnerReferencePatch] { + return pulumix.Output[OwnerReferencePatch]{ + OutputState: o.OutputState, + } +} + // API version of the referent. func (o OwnerReferencePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v OwnerReferencePatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4692,6 +5287,12 @@ func (o OwnerReferencePatchArrayOutput) ToOwnerReferencePatchArrayOutputWithCont return o } +func (o OwnerReferencePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]OwnerReferencePatch] { + return pulumix.Output[[]OwnerReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o OwnerReferencePatchArrayOutput) Index(i pulumi.IntInput) OwnerReferencePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) OwnerReferencePatch { return vs[0].([]OwnerReferencePatch)[vs[1].(int)] @@ -4737,6 +5338,12 @@ func (i PreconditionsArgs) ToPreconditionsOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PreconditionsOutput) } +func (i PreconditionsArgs) ToOutput(ctx context.Context) pulumix.Output[Preconditions] { + return pulumix.Output[Preconditions]{ + OutputState: i.ToPreconditionsOutputWithContext(ctx).OutputState, + } +} + func (i PreconditionsArgs) ToPreconditionsPtrOutput() PreconditionsPtrOutput { return i.ToPreconditionsPtrOutputWithContext(context.Background()) } @@ -4778,6 +5385,12 @@ func (i *preconditionsPtrType) ToPreconditionsPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(PreconditionsPtrOutput) } +func (i *preconditionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*Preconditions] { + return pulumix.Output[*Preconditions]{ + OutputState: i.ToPreconditionsPtrOutputWithContext(ctx).OutputState, + } +} + // Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. type PreconditionsOutput struct{ *pulumi.OutputState } @@ -4803,6 +5416,12 @@ func (o PreconditionsOutput) ToPreconditionsPtrOutputWithContext(ctx context.Con }).(PreconditionsPtrOutput) } +func (o PreconditionsOutput) ToOutput(ctx context.Context) pulumix.Output[Preconditions] { + return pulumix.Output[Preconditions]{ + OutputState: o.OutputState, + } +} + // Specifies the target ResourceVersion func (o PreconditionsOutput) ResourceVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Preconditions) *string { return v.ResourceVersion }).(pulumi.StringPtrOutput) @@ -4827,6 +5446,12 @@ func (o PreconditionsPtrOutput) ToPreconditionsPtrOutputWithContext(ctx context. return o } +func (o PreconditionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Preconditions] { + return pulumix.Output[*Preconditions]{ + OutputState: o.OutputState, + } +} + func (o PreconditionsPtrOutput) Elem() PreconditionsOutput { return o.ApplyT(func(v *Preconditions) Preconditions { if v != nil { @@ -4896,6 +5521,12 @@ func (i PreconditionsPatchArgs) ToPreconditionsPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PreconditionsPatchOutput) } +func (i PreconditionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PreconditionsPatch] { + return pulumix.Output[PreconditionsPatch]{ + OutputState: i.ToPreconditionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i PreconditionsPatchArgs) ToPreconditionsPatchPtrOutput() PreconditionsPatchPtrOutput { return i.ToPreconditionsPatchPtrOutputWithContext(context.Background()) } @@ -4937,6 +5568,12 @@ func (i *preconditionsPatchPtrType) ToPreconditionsPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PreconditionsPatchPtrOutput) } +func (i *preconditionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PreconditionsPatch] { + return pulumix.Output[*PreconditionsPatch]{ + OutputState: i.ToPreconditionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. type PreconditionsPatchOutput struct{ *pulumi.OutputState } @@ -4962,6 +5599,12 @@ func (o PreconditionsPatchOutput) ToPreconditionsPatchPtrOutputWithContext(ctx c }).(PreconditionsPatchPtrOutput) } +func (o PreconditionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PreconditionsPatch] { + return pulumix.Output[PreconditionsPatch]{ + OutputState: o.OutputState, + } +} + // Specifies the target ResourceVersion func (o PreconditionsPatchOutput) ResourceVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PreconditionsPatch) *string { return v.ResourceVersion }).(pulumi.StringPtrOutput) @@ -4986,6 +5629,12 @@ func (o PreconditionsPatchPtrOutput) ToPreconditionsPatchPtrOutputWithContext(ct return o } +func (o PreconditionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PreconditionsPatch] { + return pulumix.Output[*PreconditionsPatch]{ + OutputState: o.OutputState, + } +} + func (o PreconditionsPatchPtrOutput) Elem() PreconditionsPatchOutput { return o.ApplyT(func(v *PreconditionsPatch) PreconditionsPatch { if v != nil { @@ -5055,6 +5704,12 @@ func (i ServerAddressByClientCIDRArgs) ToServerAddressByClientCIDROutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ServerAddressByClientCIDROutput) } +func (i ServerAddressByClientCIDRArgs) ToOutput(ctx context.Context) pulumix.Output[ServerAddressByClientCIDR] { + return pulumix.Output[ServerAddressByClientCIDR]{ + OutputState: i.ToServerAddressByClientCIDROutputWithContext(ctx).OutputState, + } +} + // ServerAddressByClientCIDRArrayInput is an input type that accepts ServerAddressByClientCIDRArray and ServerAddressByClientCIDRArrayOutput values. // You can construct a concrete instance of `ServerAddressByClientCIDRArrayInput` via: // @@ -5080,6 +5735,12 @@ func (i ServerAddressByClientCIDRArray) ToServerAddressByClientCIDRArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ServerAddressByClientCIDRArrayOutput) } +func (i ServerAddressByClientCIDRArray) ToOutput(ctx context.Context) pulumix.Output[[]ServerAddressByClientCIDR] { + return pulumix.Output[[]ServerAddressByClientCIDR]{ + OutputState: i.ToServerAddressByClientCIDRArrayOutputWithContext(ctx).OutputState, + } +} + // ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match. type ServerAddressByClientCIDROutput struct{ *pulumi.OutputState } @@ -5095,6 +5756,12 @@ func (o ServerAddressByClientCIDROutput) ToServerAddressByClientCIDROutputWithCo return o } +func (o ServerAddressByClientCIDROutput) ToOutput(ctx context.Context) pulumix.Output[ServerAddressByClientCIDR] { + return pulumix.Output[ServerAddressByClientCIDR]{ + OutputState: o.OutputState, + } +} + // The CIDR with which clients can match their IP to figure out the server address that they should use. func (o ServerAddressByClientCIDROutput) ClientCIDR() pulumi.StringOutput { return o.ApplyT(func(v ServerAddressByClientCIDR) string { return v.ClientCIDR }).(pulumi.StringOutput) @@ -5119,6 +5786,12 @@ func (o ServerAddressByClientCIDRArrayOutput) ToServerAddressByClientCIDRArrayOu return o } +func (o ServerAddressByClientCIDRArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ServerAddressByClientCIDR] { + return pulumix.Output[[]ServerAddressByClientCIDR]{ + OutputState: o.OutputState, + } +} + func (o ServerAddressByClientCIDRArrayOutput) Index(i pulumi.IntInput) ServerAddressByClientCIDROutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServerAddressByClientCIDR { return vs[0].([]ServerAddressByClientCIDR)[vs[1].(int)] @@ -5164,6 +5837,12 @@ func (i ServerAddressByClientCIDRPatchArgs) ToServerAddressByClientCIDRPatchOutp return pulumi.ToOutputWithContext(ctx, i).(ServerAddressByClientCIDRPatchOutput) } +func (i ServerAddressByClientCIDRPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServerAddressByClientCIDRPatch] { + return pulumix.Output[ServerAddressByClientCIDRPatch]{ + OutputState: i.ToServerAddressByClientCIDRPatchOutputWithContext(ctx).OutputState, + } +} + // ServerAddressByClientCIDRPatchArrayInput is an input type that accepts ServerAddressByClientCIDRPatchArray and ServerAddressByClientCIDRPatchArrayOutput values. // You can construct a concrete instance of `ServerAddressByClientCIDRPatchArrayInput` via: // @@ -5189,6 +5868,12 @@ func (i ServerAddressByClientCIDRPatchArray) ToServerAddressByClientCIDRPatchArr return pulumi.ToOutputWithContext(ctx, i).(ServerAddressByClientCIDRPatchArrayOutput) } +func (i ServerAddressByClientCIDRPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ServerAddressByClientCIDRPatch] { + return pulumix.Output[[]ServerAddressByClientCIDRPatch]{ + OutputState: i.ToServerAddressByClientCIDRPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match. type ServerAddressByClientCIDRPatchOutput struct{ *pulumi.OutputState } @@ -5204,6 +5889,12 @@ func (o ServerAddressByClientCIDRPatchOutput) ToServerAddressByClientCIDRPatchOu return o } +func (o ServerAddressByClientCIDRPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServerAddressByClientCIDRPatch] { + return pulumix.Output[ServerAddressByClientCIDRPatch]{ + OutputState: o.OutputState, + } +} + // The CIDR with which clients can match their IP to figure out the server address that they should use. func (o ServerAddressByClientCIDRPatchOutput) ClientCIDR() pulumi.StringPtrOutput { return o.ApplyT(func(v ServerAddressByClientCIDRPatch) *string { return v.ClientCIDR }).(pulumi.StringPtrOutput) @@ -5228,6 +5919,12 @@ func (o ServerAddressByClientCIDRPatchArrayOutput) ToServerAddressByClientCIDRPa return o } +func (o ServerAddressByClientCIDRPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ServerAddressByClientCIDRPatch] { + return pulumix.Output[[]ServerAddressByClientCIDRPatch]{ + OutputState: o.OutputState, + } +} + func (o ServerAddressByClientCIDRPatchArrayOutput) Index(i pulumi.IntInput) ServerAddressByClientCIDRPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServerAddressByClientCIDRPatch { return vs[0].([]ServerAddressByClientCIDRPatch)[vs[1].(int)] @@ -5297,6 +5994,12 @@ func (i StatusTypeArgs) ToStatusTypeOutputWithContext(ctx context.Context) Statu return pulumi.ToOutputWithContext(ctx, i).(StatusTypeOutput) } +func (i StatusTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatusType] { + return pulumix.Output[StatusType]{ + OutputState: i.ToStatusTypeOutputWithContext(ctx).OutputState, + } +} + // Status is a return value for calls that don't return other objects. type StatusTypeOutput struct{ *pulumi.OutputState } @@ -5312,6 +6015,12 @@ func (o StatusTypeOutput) ToStatusTypeOutputWithContext(ctx context.Context) Sta return o } +func (o StatusTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatusType] { + return pulumix.Output[StatusType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatusTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatusType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5403,6 +6112,12 @@ func (i StatusCauseArgs) ToStatusCauseOutputWithContext(ctx context.Context) Sta return pulumi.ToOutputWithContext(ctx, i).(StatusCauseOutput) } +func (i StatusCauseArgs) ToOutput(ctx context.Context) pulumix.Output[StatusCause] { + return pulumix.Output[StatusCause]{ + OutputState: i.ToStatusCauseOutputWithContext(ctx).OutputState, + } +} + // StatusCauseArrayInput is an input type that accepts StatusCauseArray and StatusCauseArrayOutput values. // You can construct a concrete instance of `StatusCauseArrayInput` via: // @@ -5428,6 +6143,12 @@ func (i StatusCauseArray) ToStatusCauseArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(StatusCauseArrayOutput) } +func (i StatusCauseArray) ToOutput(ctx context.Context) pulumix.Output[[]StatusCause] { + return pulumix.Output[[]StatusCause]{ + OutputState: i.ToStatusCauseArrayOutputWithContext(ctx).OutputState, + } +} + // StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered. type StatusCauseOutput struct{ *pulumi.OutputState } @@ -5443,6 +6164,12 @@ func (o StatusCauseOutput) ToStatusCauseOutputWithContext(ctx context.Context) S return o } +func (o StatusCauseOutput) ToOutput(ctx context.Context) pulumix.Output[StatusCause] { + return pulumix.Output[StatusCause]{ + OutputState: o.OutputState, + } +} + // The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional. // // Examples: @@ -5477,6 +6204,12 @@ func (o StatusCauseArrayOutput) ToStatusCauseArrayOutputWithContext(ctx context. return o } +func (o StatusCauseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatusCause] { + return pulumix.Output[[]StatusCause]{ + OutputState: o.OutputState, + } +} + func (o StatusCauseArrayOutput) Index(i pulumi.IntInput) StatusCauseOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatusCause { return vs[0].([]StatusCause)[vs[1].(int)] @@ -5534,6 +6267,12 @@ func (i StatusCausePatchArgs) ToStatusCausePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StatusCausePatchOutput) } +func (i StatusCausePatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatusCausePatch] { + return pulumix.Output[StatusCausePatch]{ + OutputState: i.ToStatusCausePatchOutputWithContext(ctx).OutputState, + } +} + // StatusCausePatchArrayInput is an input type that accepts StatusCausePatchArray and StatusCausePatchArrayOutput values. // You can construct a concrete instance of `StatusCausePatchArrayInput` via: // @@ -5559,6 +6298,12 @@ func (i StatusCausePatchArray) ToStatusCausePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StatusCausePatchArrayOutput) } +func (i StatusCausePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]StatusCausePatch] { + return pulumix.Output[[]StatusCausePatch]{ + OutputState: i.ToStatusCausePatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered. type StatusCausePatchOutput struct{ *pulumi.OutputState } @@ -5574,6 +6319,12 @@ func (o StatusCausePatchOutput) ToStatusCausePatchOutputWithContext(ctx context. return o } +func (o StatusCausePatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatusCausePatch] { + return pulumix.Output[StatusCausePatch]{ + OutputState: o.OutputState, + } +} + // The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional. // // Examples: @@ -5608,6 +6359,12 @@ func (o StatusCausePatchArrayOutput) ToStatusCausePatchArrayOutputWithContext(ct return o } +func (o StatusCausePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StatusCausePatch] { + return pulumix.Output[[]StatusCausePatch]{ + OutputState: o.OutputState, + } +} + func (o StatusCausePatchArrayOutput) Index(i pulumi.IntInput) StatusCausePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StatusCausePatch { return vs[0].([]StatusCausePatch)[vs[1].(int)] @@ -5669,6 +6426,12 @@ func (i StatusDetailsArgs) ToStatusDetailsOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(StatusDetailsOutput) } +func (i StatusDetailsArgs) ToOutput(ctx context.Context) pulumix.Output[StatusDetails] { + return pulumix.Output[StatusDetails]{ + OutputState: i.ToStatusDetailsOutputWithContext(ctx).OutputState, + } +} + func (i StatusDetailsArgs) ToStatusDetailsPtrOutput() StatusDetailsPtrOutput { return i.ToStatusDetailsPtrOutputWithContext(context.Background()) } @@ -5710,6 +6473,12 @@ func (i *statusDetailsPtrType) ToStatusDetailsPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(StatusDetailsPtrOutput) } +func (i *statusDetailsPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatusDetails] { + return pulumix.Output[*StatusDetails]{ + OutputState: i.ToStatusDetailsPtrOutputWithContext(ctx).OutputState, + } +} + // StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. type StatusDetailsOutput struct{ *pulumi.OutputState } @@ -5735,6 +6504,12 @@ func (o StatusDetailsOutput) ToStatusDetailsPtrOutputWithContext(ctx context.Con }).(StatusDetailsPtrOutput) } +func (o StatusDetailsOutput) ToOutput(ctx context.Context) pulumix.Output[StatusDetails] { + return pulumix.Output[StatusDetails]{ + OutputState: o.OutputState, + } +} + // The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. func (o StatusDetailsOutput) Causes() StatusCauseArrayOutput { return o.ApplyT(func(v StatusDetails) []StatusCause { return v.Causes }).(StatusCauseArrayOutput) @@ -5779,6 +6554,12 @@ func (o StatusDetailsPtrOutput) ToStatusDetailsPtrOutputWithContext(ctx context. return o } +func (o StatusDetailsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatusDetails] { + return pulumix.Output[*StatusDetails]{ + OutputState: o.OutputState, + } +} + func (o StatusDetailsPtrOutput) Elem() StatusDetailsOutput { return o.ApplyT(func(v *StatusDetails) StatusDetails { if v != nil { @@ -5904,6 +6685,12 @@ func (i StatusDetailsPatchArgs) ToStatusDetailsPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StatusDetailsPatchOutput) } +func (i StatusDetailsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[StatusDetailsPatch] { + return pulumix.Output[StatusDetailsPatch]{ + OutputState: i.ToStatusDetailsPatchOutputWithContext(ctx).OutputState, + } +} + func (i StatusDetailsPatchArgs) ToStatusDetailsPatchPtrOutput() StatusDetailsPatchPtrOutput { return i.ToStatusDetailsPatchPtrOutputWithContext(context.Background()) } @@ -5945,6 +6732,12 @@ func (i *statusDetailsPatchPtrType) ToStatusDetailsPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(StatusDetailsPatchPtrOutput) } +func (i *statusDetailsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*StatusDetailsPatch] { + return pulumix.Output[*StatusDetailsPatch]{ + OutputState: i.ToStatusDetailsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. type StatusDetailsPatchOutput struct{ *pulumi.OutputState } @@ -5970,6 +6763,12 @@ func (o StatusDetailsPatchOutput) ToStatusDetailsPatchPtrOutputWithContext(ctx c }).(StatusDetailsPatchPtrOutput) } +func (o StatusDetailsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[StatusDetailsPatch] { + return pulumix.Output[StatusDetailsPatch]{ + OutputState: o.OutputState, + } +} + // The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. func (o StatusDetailsPatchOutput) Causes() StatusCausePatchArrayOutput { return o.ApplyT(func(v StatusDetailsPatch) []StatusCausePatch { return v.Causes }).(StatusCausePatchArrayOutput) @@ -6014,6 +6813,12 @@ func (o StatusDetailsPatchPtrOutput) ToStatusDetailsPatchPtrOutputWithContext(ct return o } +func (o StatusDetailsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StatusDetailsPatch] { + return pulumix.Output[*StatusDetailsPatch]{ + OutputState: o.OutputState, + } +} + func (o StatusDetailsPatchPtrOutput) Elem() StatusDetailsPatchOutput { return o.ApplyT(func(v *StatusDetailsPatch) StatusDetailsPatch { if v != nil { @@ -6147,6 +6952,12 @@ func (i StatusPatchTypeArgs) ToStatusPatchTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StatusPatchTypeOutput) } +func (i StatusPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StatusPatchType] { + return pulumix.Output[StatusPatchType]{ + OutputState: i.ToStatusPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Status is a return value for calls that don't return other objects. type StatusPatchTypeOutput struct{ *pulumi.OutputState } @@ -6162,6 +6973,12 @@ func (o StatusPatchTypeOutput) ToStatusPatchTypeOutputWithContext(ctx context.Co return o } +func (o StatusPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StatusPatchType] { + return pulumix.Output[StatusPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatusPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StatusPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -6247,6 +7064,12 @@ func (i WatchEventArgs) ToWatchEventOutputWithContext(ctx context.Context) Watch return pulumi.ToOutputWithContext(ctx, i).(WatchEventOutput) } +func (i WatchEventArgs) ToOutput(ctx context.Context) pulumix.Output[WatchEvent] { + return pulumix.Output[WatchEvent]{ + OutputState: i.ToWatchEventOutputWithContext(ctx).OutputState, + } +} + // Event represents a single event to a watched resource. type WatchEventOutput struct{ *pulumi.OutputState } @@ -6262,6 +7085,12 @@ func (o WatchEventOutput) ToWatchEventOutputWithContext(ctx context.Context) Wat return o } +func (o WatchEventOutput) ToOutput(ctx context.Context) pulumix.Output[WatchEvent] { + return pulumix.Output[WatchEvent]{ + OutputState: o.OutputState, + } +} + // Object is: // - If Type is Added or Modified: the new state of the object. // - If Type is Deleted: the state of the object immediately before deletion. @@ -6320,6 +7149,12 @@ func (i WatchEventPatchArgs) ToWatchEventPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(WatchEventPatchOutput) } +func (i WatchEventPatchArgs) ToOutput(ctx context.Context) pulumix.Output[WatchEventPatch] { + return pulumix.Output[WatchEventPatch]{ + OutputState: i.ToWatchEventPatchOutputWithContext(ctx).OutputState, + } +} + // Event represents a single event to a watched resource. type WatchEventPatchOutput struct{ *pulumi.OutputState } @@ -6335,6 +7170,12 @@ func (o WatchEventPatchOutput) ToWatchEventPatchOutputWithContext(ctx context.Co return o } +func (o WatchEventPatchOutput) ToOutput(ctx context.Context) pulumix.Output[WatchEventPatch] { + return pulumix.Output[WatchEventPatch]{ + OutputState: o.OutputState, + } +} + // Object is: // - If Type is Added or Modified: the new state of the object. // - If Type is Deleted: the state of the object immediately before deletion. diff --git a/sdk/go/kubernetes/meta/v1/status.go b/sdk/go/kubernetes/meta/v1/status.go index 514052b30a..857679b7b3 100644 --- a/sdk/go/kubernetes/meta/v1/status.go +++ b/sdk/go/kubernetes/meta/v1/status.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Status is a return value for calls that don't return other objects. @@ -132,6 +133,12 @@ func (i *Status) ToStatusOutputWithContext(ctx context.Context) StatusOutput { return pulumi.ToOutputWithContext(ctx, i).(StatusOutput) } +func (i *Status) ToOutput(ctx context.Context) pulumix.Output[*Status] { + return pulumix.Output[*Status]{ + OutputState: i.ToStatusOutputWithContext(ctx).OutputState, + } +} + // StatusArrayInput is an input type that accepts StatusArray and StatusArrayOutput values. // You can construct a concrete instance of `StatusArrayInput` via: // @@ -157,6 +164,12 @@ func (i StatusArray) ToStatusArrayOutputWithContext(ctx context.Context) StatusA return pulumi.ToOutputWithContext(ctx, i).(StatusArrayOutput) } +func (i StatusArray) ToOutput(ctx context.Context) pulumix.Output[[]*Status] { + return pulumix.Output[[]*Status]{ + OutputState: i.ToStatusArrayOutputWithContext(ctx).OutputState, + } +} + // StatusMapInput is an input type that accepts StatusMap and StatusMapOutput values. // You can construct a concrete instance of `StatusMapInput` via: // @@ -182,6 +195,12 @@ func (i StatusMap) ToStatusMapOutputWithContext(ctx context.Context) StatusMapOu return pulumi.ToOutputWithContext(ctx, i).(StatusMapOutput) } +func (i StatusMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Status] { + return pulumix.Output[map[string]*Status]{ + OutputState: i.ToStatusMapOutputWithContext(ctx).OutputState, + } +} + type StatusOutput struct{ *pulumi.OutputState } func (StatusOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o StatusOutput) ToStatusOutputWithContext(ctx context.Context) StatusOutpu return o } +func (o StatusOutput) ToOutput(ctx context.Context) pulumix.Output[*Status] { + return pulumix.Output[*Status]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatusOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Status) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -250,6 +275,12 @@ func (o StatusArrayOutput) ToStatusArrayOutputWithContext(ctx context.Context) S return o } +func (o StatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Status] { + return pulumix.Output[[]*Status]{ + OutputState: o.OutputState, + } +} + func (o StatusArrayOutput) Index(i pulumi.IntInput) StatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Status { return vs[0].([]*Status)[vs[1].(int)] @@ -270,6 +301,12 @@ func (o StatusMapOutput) ToStatusMapOutputWithContext(ctx context.Context) Statu return o } +func (o StatusMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Status] { + return pulumix.Output[map[string]*Status]{ + OutputState: o.OutputState, + } +} + func (o StatusMapOutput) MapIndex(k pulumi.StringInput) StatusOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Status { return vs[0].(map[string]*Status)[vs[1].(string)] diff --git a/sdk/go/kubernetes/meta/v1/statusPatch.go b/sdk/go/kubernetes/meta/v1/statusPatch.go index ee1d123f1f..d46db35216 100644 --- a/sdk/go/kubernetes/meta/v1/statusPatch.go +++ b/sdk/go/kubernetes/meta/v1/statusPatch.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -138,6 +139,12 @@ func (i *StatusPatch) ToStatusPatchOutputWithContext(ctx context.Context) Status return pulumi.ToOutputWithContext(ctx, i).(StatusPatchOutput) } +func (i *StatusPatch) ToOutput(ctx context.Context) pulumix.Output[*StatusPatch] { + return pulumix.Output[*StatusPatch]{ + OutputState: i.ToStatusPatchOutputWithContext(ctx).OutputState, + } +} + // StatusPatchArrayInput is an input type that accepts StatusPatchArray and StatusPatchArrayOutput values. // You can construct a concrete instance of `StatusPatchArrayInput` via: // @@ -163,6 +170,12 @@ func (i StatusPatchArray) ToStatusPatchArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(StatusPatchArrayOutput) } +func (i StatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*StatusPatch] { + return pulumix.Output[[]*StatusPatch]{ + OutputState: i.ToStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StatusPatchMapInput is an input type that accepts StatusPatchMap and StatusPatchMapOutput values. // You can construct a concrete instance of `StatusPatchMapInput` via: // @@ -188,6 +201,12 @@ func (i StatusPatchMap) ToStatusPatchMapOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(StatusPatchMapOutput) } +func (i StatusPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatusPatch] { + return pulumix.Output[map[string]*StatusPatch]{ + OutputState: i.ToStatusPatchMapOutputWithContext(ctx).OutputState, + } +} + type StatusPatchOutput struct{ *pulumi.OutputState } func (StatusPatchOutput) ElementType() reflect.Type { @@ -202,6 +221,12 @@ func (o StatusPatchOutput) ToStatusPatchOutputWithContext(ctx context.Context) S return o } +func (o StatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*StatusPatch] { + return pulumix.Output[*StatusPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StatusPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *StatusPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -256,6 +281,12 @@ func (o StatusPatchArrayOutput) ToStatusPatchArrayOutputWithContext(ctx context. return o } +func (o StatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StatusPatch] { + return pulumix.Output[[]*StatusPatch]{ + OutputState: o.OutputState, + } +} + func (o StatusPatchArrayOutput) Index(i pulumi.IntInput) StatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StatusPatch { return vs[0].([]*StatusPatch)[vs[1].(int)] @@ -276,6 +307,12 @@ func (o StatusPatchMapOutput) ToStatusPatchMapOutputWithContext(ctx context.Cont return o } +func (o StatusPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StatusPatch] { + return pulumix.Output[map[string]*StatusPatch]{ + OutputState: o.OutputState, + } +} + func (o StatusPatchMapOutput) MapIndex(k pulumi.StringInput) StatusPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StatusPatch { return vs[0].(map[string]*StatusPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/ingress.go b/sdk/go/kubernetes/networking/v1/ingress.go index 0f22546186..e16b6a652b 100644 --- a/sdk/go/kubernetes/networking/v1/ingress.go +++ b/sdk/go/kubernetes/networking/v1/ingress.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. @@ -243,6 +244,12 @@ func (i *Ingress) ToIngressOutputWithContext(ctx context.Context) IngressOutput return pulumi.ToOutputWithContext(ctx, i).(IngressOutput) } +func (i *Ingress) ToOutput(ctx context.Context) pulumix.Output[*Ingress] { + return pulumix.Output[*Ingress]{ + OutputState: i.ToIngressOutputWithContext(ctx).OutputState, + } +} + // IngressArrayInput is an input type that accepts IngressArray and IngressArrayOutput values. // You can construct a concrete instance of `IngressArrayInput` via: // @@ -268,6 +275,12 @@ func (i IngressArray) ToIngressArrayOutputWithContext(ctx context.Context) Ingre return pulumi.ToOutputWithContext(ctx, i).(IngressArrayOutput) } +func (i IngressArray) ToOutput(ctx context.Context) pulumix.Output[[]*Ingress] { + return pulumix.Output[[]*Ingress]{ + OutputState: i.ToIngressArrayOutputWithContext(ctx).OutputState, + } +} + // IngressMapInput is an input type that accepts IngressMap and IngressMapOutput values. // You can construct a concrete instance of `IngressMapInput` via: // @@ -293,6 +306,12 @@ func (i IngressMap) ToIngressMapOutputWithContext(ctx context.Context) IngressMa return pulumi.ToOutputWithContext(ctx, i).(IngressMapOutput) } +func (i IngressMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Ingress] { + return pulumix.Output[map[string]*Ingress]{ + OutputState: i.ToIngressMapOutputWithContext(ctx).OutputState, + } +} + type IngressOutput struct{ *pulumi.OutputState } func (IngressOutput) ElementType() reflect.Type { @@ -307,6 +326,12 @@ func (o IngressOutput) ToIngressOutputWithContext(ctx context.Context) IngressOu return o } +func (o IngressOutput) ToOutput(ctx context.Context) pulumix.Output[*Ingress] { + return pulumix.Output[*Ingress]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Ingress) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -346,6 +371,12 @@ func (o IngressArrayOutput) ToIngressArrayOutputWithContext(ctx context.Context) return o } +func (o IngressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Ingress] { + return pulumix.Output[[]*Ingress]{ + OutputState: o.OutputState, + } +} + func (o IngressArrayOutput) Index(i pulumi.IntInput) IngressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Ingress { return vs[0].([]*Ingress)[vs[1].(int)] @@ -366,6 +397,12 @@ func (o IngressMapOutput) ToIngressMapOutputWithContext(ctx context.Context) Ing return o } +func (o IngressMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Ingress] { + return pulumix.Output[map[string]*Ingress]{ + OutputState: o.OutputState, + } +} + func (o IngressMapOutput) MapIndex(k pulumi.StringInput) IngressOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Ingress { return vs[0].(map[string]*Ingress)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/ingressClass.go b/sdk/go/kubernetes/networking/v1/ingressClass.go index e659c56488..a108caae97 100644 --- a/sdk/go/kubernetes/networking/v1/ingressClass.go +++ b/sdk/go/kubernetes/networking/v1/ingressClass.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. @@ -119,6 +120,12 @@ func (i *IngressClass) ToIngressClassOutputWithContext(ctx context.Context) Ingr return pulumi.ToOutputWithContext(ctx, i).(IngressClassOutput) } +func (i *IngressClass) ToOutput(ctx context.Context) pulumix.Output[*IngressClass] { + return pulumix.Output[*IngressClass]{ + OutputState: i.ToIngressClassOutputWithContext(ctx).OutputState, + } +} + // IngressClassArrayInput is an input type that accepts IngressClassArray and IngressClassArrayOutput values. // You can construct a concrete instance of `IngressClassArrayInput` via: // @@ -144,6 +151,12 @@ func (i IngressClassArray) ToIngressClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressClassArrayOutput) } +func (i IngressClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClass] { + return pulumix.Output[[]*IngressClass]{ + OutputState: i.ToIngressClassArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClassMapInput is an input type that accepts IngressClassMap and IngressClassMapOutput values. // You can construct a concrete instance of `IngressClassMapInput` via: // @@ -169,6 +182,12 @@ func (i IngressClassMap) ToIngressClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressClassMapOutput) } +func (i IngressClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClass] { + return pulumix.Output[map[string]*IngressClass]{ + OutputState: i.ToIngressClassMapOutputWithContext(ctx).OutputState, + } +} + type IngressClassOutput struct{ *pulumi.OutputState } func (IngressClassOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o IngressClassOutput) ToIngressClassOutputWithContext(ctx context.Context) return o } +func (o IngressClassOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClass] { + return pulumix.Output[*IngressClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o IngressClassArrayOutput) ToIngressClassArrayOutputWithContext(ctx contex return o } +func (o IngressClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClass] { + return pulumix.Output[[]*IngressClass]{ + OutputState: o.OutputState, + } +} + func (o IngressClassArrayOutput) Index(i pulumi.IntInput) IngressClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressClass { return vs[0].([]*IngressClass)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o IngressClassMapOutput) ToIngressClassMapOutputWithContext(ctx context.Co return o } +func (o IngressClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClass] { + return pulumix.Output[map[string]*IngressClass]{ + OutputState: o.OutputState, + } +} + func (o IngressClassMapOutput) MapIndex(k pulumi.StringInput) IngressClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressClass { return vs[0].(map[string]*IngressClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/ingressClassList.go b/sdk/go/kubernetes/networking/v1/ingressClassList.go index d149168a95..81abd2ee09 100644 --- a/sdk/go/kubernetes/networking/v1/ingressClassList.go +++ b/sdk/go/kubernetes/networking/v1/ingressClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressClassList is a collection of IngressClasses. @@ -117,6 +118,12 @@ func (i *IngressClassList) ToIngressClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(IngressClassListOutput) } +func (i *IngressClassList) ToOutput(ctx context.Context) pulumix.Output[*IngressClassList] { + return pulumix.Output[*IngressClassList]{ + OutputState: i.ToIngressClassListOutputWithContext(ctx).OutputState, + } +} + // IngressClassListArrayInput is an input type that accepts IngressClassListArray and IngressClassListArrayOutput values. // You can construct a concrete instance of `IngressClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i IngressClassListArray) ToIngressClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressClassListArrayOutput) } +func (i IngressClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassList] { + return pulumix.Output[[]*IngressClassList]{ + OutputState: i.ToIngressClassListArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClassListMapInput is an input type that accepts IngressClassListMap and IngressClassListMapOutput values. // You can construct a concrete instance of `IngressClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i IngressClassListMap) ToIngressClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(IngressClassListMapOutput) } +func (i IngressClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassList] { + return pulumix.Output[map[string]*IngressClassList]{ + OutputState: i.ToIngressClassListMapOutputWithContext(ctx).OutputState, + } +} + type IngressClassListOutput struct{ *pulumi.OutputState } func (IngressClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o IngressClassListOutput) ToIngressClassListOutputWithContext(ctx context. return o } +func (o IngressClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassList] { + return pulumix.Output[*IngressClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o IngressClassListArrayOutput) ToIngressClassListArrayOutputWithContext(ct return o } +func (o IngressClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassList] { + return pulumix.Output[[]*IngressClassList]{ + OutputState: o.OutputState, + } +} + func (o IngressClassListArrayOutput) Index(i pulumi.IntInput) IngressClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressClassList { return vs[0].([]*IngressClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o IngressClassListMapOutput) ToIngressClassListMapOutputWithContext(ctx co return o } +func (o IngressClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassList] { + return pulumix.Output[map[string]*IngressClassList]{ + OutputState: o.OutputState, + } +} + func (o IngressClassListMapOutput) MapIndex(k pulumi.StringInput) IngressClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressClassList { return vs[0].(map[string]*IngressClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/ingressClassPatch.go b/sdk/go/kubernetes/networking/v1/ingressClassPatch.go index 7e945374b6..24af7a5027 100644 --- a/sdk/go/kubernetes/networking/v1/ingressClassPatch.go +++ b/sdk/go/kubernetes/networking/v1/ingressClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *IngressClassPatch) ToIngressClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchOutput) } +func (i *IngressClassPatch) ToOutput(ctx context.Context) pulumix.Output[*IngressClassPatch] { + return pulumix.Output[*IngressClassPatch]{ + OutputState: i.ToIngressClassPatchOutputWithContext(ctx).OutputState, + } +} + // IngressClassPatchArrayInput is an input type that accepts IngressClassPatchArray and IngressClassPatchArrayOutput values. // You can construct a concrete instance of `IngressClassPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i IngressClassPatchArray) ToIngressClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchArrayOutput) } +func (i IngressClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassPatch] { + return pulumix.Output[[]*IngressClassPatch]{ + OutputState: i.ToIngressClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClassPatchMapInput is an input type that accepts IngressClassPatchMap and IngressClassPatchMapOutput values. // You can construct a concrete instance of `IngressClassPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i IngressClassPatchMap) ToIngressClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchMapOutput) } +func (i IngressClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassPatch] { + return pulumix.Output[map[string]*IngressClassPatch]{ + OutputState: i.ToIngressClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type IngressClassPatchOutput struct{ *pulumi.OutputState } func (IngressClassPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o IngressClassPatchOutput) ToIngressClassPatchOutputWithContext(ctx contex return o } +func (o IngressClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassPatch] { + return pulumix.Output[*IngressClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *IngressClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o IngressClassPatchArrayOutput) ToIngressClassPatchArrayOutputWithContext( return o } +func (o IngressClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassPatch] { + return pulumix.Output[[]*IngressClassPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassPatchArrayOutput) Index(i pulumi.IntInput) IngressClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressClassPatch { return vs[0].([]*IngressClassPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o IngressClassPatchMapOutput) ToIngressClassPatchMapOutputWithContext(ctx return o } +func (o IngressClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassPatch] { + return pulumix.Output[map[string]*IngressClassPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassPatchMapOutput) MapIndex(k pulumi.StringInput) IngressClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressClassPatch { return vs[0].(map[string]*IngressClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/ingressList.go b/sdk/go/kubernetes/networking/v1/ingressList.go index a7aaf9a765..0df800e9b7 100644 --- a/sdk/go/kubernetes/networking/v1/ingressList.go +++ b/sdk/go/kubernetes/networking/v1/ingressList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressList is a collection of Ingress. @@ -117,6 +118,12 @@ func (i *IngressList) ToIngressListOutputWithContext(ctx context.Context) Ingres return pulumi.ToOutputWithContext(ctx, i).(IngressListOutput) } +func (i *IngressList) ToOutput(ctx context.Context) pulumix.Output[*IngressList] { + return pulumix.Output[*IngressList]{ + OutputState: i.ToIngressListOutputWithContext(ctx).OutputState, + } +} + // IngressListArrayInput is an input type that accepts IngressListArray and IngressListArrayOutput values. // You can construct a concrete instance of `IngressListArrayInput` via: // @@ -142,6 +149,12 @@ func (i IngressListArray) ToIngressListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressListArrayOutput) } +func (i IngressListArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressList] { + return pulumix.Output[[]*IngressList]{ + OutputState: i.ToIngressListArrayOutputWithContext(ctx).OutputState, + } +} + // IngressListMapInput is an input type that accepts IngressListMap and IngressListMapOutput values. // You can construct a concrete instance of `IngressListMapInput` via: // @@ -167,6 +180,12 @@ func (i IngressListMap) ToIngressListMapOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IngressListMapOutput) } +func (i IngressListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressList] { + return pulumix.Output[map[string]*IngressList]{ + OutputState: i.ToIngressListMapOutputWithContext(ctx).OutputState, + } +} + type IngressListOutput struct{ *pulumi.OutputState } func (IngressListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o IngressListOutput) ToIngressListOutputWithContext(ctx context.Context) I return o } +func (o IngressListOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressList] { + return pulumix.Output[*IngressList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o IngressListArrayOutput) ToIngressListArrayOutputWithContext(ctx context. return o } +func (o IngressListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressList] { + return pulumix.Output[[]*IngressList]{ + OutputState: o.OutputState, + } +} + func (o IngressListArrayOutput) Index(i pulumi.IntInput) IngressListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressList { return vs[0].([]*IngressList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o IngressListMapOutput) ToIngressListMapOutputWithContext(ctx context.Cont return o } +func (o IngressListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressList] { + return pulumix.Output[map[string]*IngressList]{ + OutputState: o.OutputState, + } +} + func (o IngressListMapOutput) MapIndex(k pulumi.StringInput) IngressListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressList { return vs[0].(map[string]*IngressList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/ingressPatch.go b/sdk/go/kubernetes/networking/v1/ingressPatch.go index ceb102b594..35e5dfaa8e 100644 --- a/sdk/go/kubernetes/networking/v1/ingressPatch.go +++ b/sdk/go/kubernetes/networking/v1/ingressPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -144,6 +145,12 @@ func (i *IngressPatch) ToIngressPatchOutputWithContext(ctx context.Context) Ingr return pulumi.ToOutputWithContext(ctx, i).(IngressPatchOutput) } +func (i *IngressPatch) ToOutput(ctx context.Context) pulumix.Output[*IngressPatch] { + return pulumix.Output[*IngressPatch]{ + OutputState: i.ToIngressPatchOutputWithContext(ctx).OutputState, + } +} + // IngressPatchArrayInput is an input type that accepts IngressPatchArray and IngressPatchArrayOutput values. // You can construct a concrete instance of `IngressPatchArrayInput` via: // @@ -169,6 +176,12 @@ func (i IngressPatchArray) ToIngressPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressPatchArrayOutput) } +func (i IngressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressPatch] { + return pulumix.Output[[]*IngressPatch]{ + OutputState: i.ToIngressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressPatchMapInput is an input type that accepts IngressPatchMap and IngressPatchMapOutput values. // You can construct a concrete instance of `IngressPatchMapInput` via: // @@ -194,6 +207,12 @@ func (i IngressPatchMap) ToIngressPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressPatchMapOutput) } +func (i IngressPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressPatch] { + return pulumix.Output[map[string]*IngressPatch]{ + OutputState: i.ToIngressPatchMapOutputWithContext(ctx).OutputState, + } +} + type IngressPatchOutput struct{ *pulumi.OutputState } func (IngressPatchOutput) ElementType() reflect.Type { @@ -208,6 +227,12 @@ func (o IngressPatchOutput) ToIngressPatchOutputWithContext(ctx context.Context) return o } +func (o IngressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressPatch] { + return pulumix.Output[*IngressPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *IngressPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -247,6 +272,12 @@ func (o IngressPatchArrayOutput) ToIngressPatchArrayOutputWithContext(ctx contex return o } +func (o IngressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressPatch] { + return pulumix.Output[[]*IngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPatchArrayOutput) Index(i pulumi.IntInput) IngressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressPatch { return vs[0].([]*IngressPatch)[vs[1].(int)] @@ -267,6 +298,12 @@ func (o IngressPatchMapOutput) ToIngressPatchMapOutputWithContext(ctx context.Co return o } +func (o IngressPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressPatch] { + return pulumix.Output[map[string]*IngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPatchMapOutput) MapIndex(k pulumi.StringInput) IngressPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressPatch { return vs[0].(map[string]*IngressPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/networkPolicy.go b/sdk/go/kubernetes/networking/v1/networkPolicy.go index effd266118..d91caf1cd7 100644 --- a/sdk/go/kubernetes/networking/v1/networkPolicy.go +++ b/sdk/go/kubernetes/networking/v1/networkPolicy.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // NetworkPolicy describes what network traffic is allowed for a set of Pods @@ -121,6 +122,12 @@ func (i *NetworkPolicy) ToNetworkPolicyOutputWithContext(ctx context.Context) Ne return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyOutput) } +func (i *NetworkPolicy) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicy] { + return pulumix.Output[*NetworkPolicy]{ + OutputState: i.ToNetworkPolicyOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyArrayInput is an input type that accepts NetworkPolicyArray and NetworkPolicyArrayOutput values. // You can construct a concrete instance of `NetworkPolicyArrayInput` via: // @@ -146,6 +153,12 @@ func (i NetworkPolicyArray) ToNetworkPolicyArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyArrayOutput) } +func (i NetworkPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicy] { + return pulumix.Output[[]*NetworkPolicy]{ + OutputState: i.ToNetworkPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyMapInput is an input type that accepts NetworkPolicyMap and NetworkPolicyMapOutput values. // You can construct a concrete instance of `NetworkPolicyMapInput` via: // @@ -171,6 +184,12 @@ func (i NetworkPolicyMap) ToNetworkPolicyMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyMapOutput) } +func (i NetworkPolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicy] { + return pulumix.Output[map[string]*NetworkPolicy]{ + OutputState: i.ToNetworkPolicyMapOutputWithContext(ctx).OutputState, + } +} + type NetworkPolicyOutput struct{ *pulumi.OutputState } func (NetworkPolicyOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o NetworkPolicyOutput) ToNetworkPolicyOutputWithContext(ctx context.Contex return o } +func (o NetworkPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicy] { + return pulumix.Output[*NetworkPolicy]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *NetworkPolicy) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o NetworkPolicyArrayOutput) ToNetworkPolicyArrayOutputWithContext(ctx cont return o } +func (o NetworkPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicy] { + return pulumix.Output[[]*NetworkPolicy]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyArrayOutput) Index(i pulumi.IntInput) NetworkPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkPolicy { return vs[0].([]*NetworkPolicy)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o NetworkPolicyMapOutput) ToNetworkPolicyMapOutputWithContext(ctx context. return o } +func (o NetworkPolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicy] { + return pulumix.Output[map[string]*NetworkPolicy]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyMapOutput) MapIndex(k pulumi.StringInput) NetworkPolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkPolicy { return vs[0].(map[string]*NetworkPolicy)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/networkPolicyList.go b/sdk/go/kubernetes/networking/v1/networkPolicyList.go index d5a1d66ae3..5a00b64871 100644 --- a/sdk/go/kubernetes/networking/v1/networkPolicyList.go +++ b/sdk/go/kubernetes/networking/v1/networkPolicyList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // NetworkPolicyList is a list of NetworkPolicy objects. @@ -117,6 +118,12 @@ func (i *NetworkPolicyList) ToNetworkPolicyListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListOutput) } +func (i *NetworkPolicyList) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyList] { + return pulumix.Output[*NetworkPolicyList]{ + OutputState: i.ToNetworkPolicyListOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyListArrayInput is an input type that accepts NetworkPolicyListArray and NetworkPolicyListArrayOutput values. // You can construct a concrete instance of `NetworkPolicyListArrayInput` via: // @@ -142,6 +149,12 @@ func (i NetworkPolicyListArray) ToNetworkPolicyListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListArrayOutput) } +func (i NetworkPolicyListArray) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyList] { + return pulumix.Output[[]*NetworkPolicyList]{ + OutputState: i.ToNetworkPolicyListArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyListMapInput is an input type that accepts NetworkPolicyListMap and NetworkPolicyListMapOutput values. // You can construct a concrete instance of `NetworkPolicyListMapInput` via: // @@ -167,6 +180,12 @@ func (i NetworkPolicyListMap) ToNetworkPolicyListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListMapOutput) } +func (i NetworkPolicyListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyList] { + return pulumix.Output[map[string]*NetworkPolicyList]{ + OutputState: i.ToNetworkPolicyListMapOutputWithContext(ctx).OutputState, + } +} + type NetworkPolicyListOutput struct{ *pulumi.OutputState } func (NetworkPolicyListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o NetworkPolicyListOutput) ToNetworkPolicyListOutputWithContext(ctx contex return o } +func (o NetworkPolicyListOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyList] { + return pulumix.Output[*NetworkPolicyList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *NetworkPolicyList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o NetworkPolicyListArrayOutput) ToNetworkPolicyListArrayOutputWithContext( return o } +func (o NetworkPolicyListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyList] { + return pulumix.Output[[]*NetworkPolicyList]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyListArrayOutput) Index(i pulumi.IntInput) NetworkPolicyListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkPolicyList { return vs[0].([]*NetworkPolicyList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o NetworkPolicyListMapOutput) ToNetworkPolicyListMapOutputWithContext(ctx return o } +func (o NetworkPolicyListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyList] { + return pulumix.Output[map[string]*NetworkPolicyList]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyListMapOutput) MapIndex(k pulumi.StringInput) NetworkPolicyListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkPolicyList { return vs[0].(map[string]*NetworkPolicyList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/networkPolicyPatch.go b/sdk/go/kubernetes/networking/v1/networkPolicyPatch.go index 86e5eac848..58921c92e8 100644 --- a/sdk/go/kubernetes/networking/v1/networkPolicyPatch.go +++ b/sdk/go/kubernetes/networking/v1/networkPolicyPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -127,6 +128,12 @@ func (i *NetworkPolicyPatch) ToNetworkPolicyPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchOutput) } +func (i *NetworkPolicyPatch) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyPatch] { + return pulumix.Output[*NetworkPolicyPatch]{ + OutputState: i.ToNetworkPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPatchArrayInput is an input type that accepts NetworkPolicyPatchArray and NetworkPolicyPatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPatchArrayInput` via: // @@ -152,6 +159,12 @@ func (i NetworkPolicyPatchArray) ToNetworkPolicyPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchArrayOutput) } +func (i NetworkPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyPatch] { + return pulumix.Output[[]*NetworkPolicyPatch]{ + OutputState: i.ToNetworkPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPatchMapInput is an input type that accepts NetworkPolicyPatchMap and NetworkPolicyPatchMapOutput values. // You can construct a concrete instance of `NetworkPolicyPatchMapInput` via: // @@ -177,6 +190,12 @@ func (i NetworkPolicyPatchMap) ToNetworkPolicyPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchMapOutput) } +func (i NetworkPolicyPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyPatch] { + return pulumix.Output[map[string]*NetworkPolicyPatch]{ + OutputState: i.ToNetworkPolicyPatchMapOutputWithContext(ctx).OutputState, + } +} + type NetworkPolicyPatchOutput struct{ *pulumi.OutputState } func (NetworkPolicyPatchOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o NetworkPolicyPatchOutput) ToNetworkPolicyPatchOutputWithContext(ctx cont return o } +func (o NetworkPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyPatch] { + return pulumix.Output[*NetworkPolicyPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *NetworkPolicyPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -230,6 +255,12 @@ func (o NetworkPolicyPatchArrayOutput) ToNetworkPolicyPatchArrayOutputWithContex return o } +func (o NetworkPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NetworkPolicyPatch] { + return pulumix.Output[[]*NetworkPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkPolicyPatch { return vs[0].([]*NetworkPolicyPatch)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o NetworkPolicyPatchMapOutput) ToNetworkPolicyPatchMapOutputWithContext(ct return o } +func (o NetworkPolicyPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NetworkPolicyPatch] { + return pulumix.Output[map[string]*NetworkPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPatchMapOutput) MapIndex(k pulumi.StringInput) NetworkPolicyPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkPolicyPatch { return vs[0].(map[string]*NetworkPolicyPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1/pulumiTypes.go b/sdk/go/kubernetes/networking/v1/pulumiTypes.go index c286959a3b..37e69619d0 100644 --- a/sdk/go/kubernetes/networking/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/networking/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -78,6 +79,12 @@ func (i HTTPIngressPathArgs) ToHTTPIngressPathOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathOutput) } +func (i HTTPIngressPathArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPath] { + return pulumix.Output[HTTPIngressPath]{ + OutputState: i.ToHTTPIngressPathOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPathArrayInput is an input type that accepts HTTPIngressPathArray and HTTPIngressPathArrayOutput values. // You can construct a concrete instance of `HTTPIngressPathArrayInput` via: // @@ -103,6 +110,12 @@ func (i HTTPIngressPathArray) ToHTTPIngressPathArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathArrayOutput) } +func (i HTTPIngressPathArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPath] { + return pulumix.Output[[]HTTPIngressPath]{ + OutputState: i.ToHTTPIngressPathArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend. type HTTPIngressPathOutput struct{ *pulumi.OutputState } @@ -118,6 +131,12 @@ func (o HTTPIngressPathOutput) ToHTTPIngressPathOutputWithContext(ctx context.Co return o } +func (o HTTPIngressPathOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPath] { + return pulumix.Output[HTTPIngressPath]{ + OutputState: o.OutputState, + } +} + // backend defines the referenced service endpoint to which the traffic will be forwarded to. func (o HTTPIngressPathOutput) Backend() IngressBackendOutput { return o.ApplyT(func(v HTTPIngressPath) IngressBackend { return v.Backend }).(IngressBackendOutput) @@ -158,6 +177,12 @@ func (o HTTPIngressPathArrayOutput) ToHTTPIngressPathArrayOutputWithContext(ctx return o } +func (o HTTPIngressPathArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPath] { + return pulumix.Output[[]HTTPIngressPath]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressPathArrayOutput) Index(i pulumi.IntInput) HTTPIngressPathOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPIngressPath { return vs[0].([]HTTPIngressPath)[vs[1].(int)] @@ -227,6 +252,12 @@ func (i HTTPIngressPathPatchArgs) ToHTTPIngressPathPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathPatchOutput) } +func (i HTTPIngressPathPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPathPatch] { + return pulumix.Output[HTTPIngressPathPatch]{ + OutputState: i.ToHTTPIngressPathPatchOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPathPatchArrayInput is an input type that accepts HTTPIngressPathPatchArray and HTTPIngressPathPatchArrayOutput values. // You can construct a concrete instance of `HTTPIngressPathPatchArrayInput` via: // @@ -252,6 +283,12 @@ func (i HTTPIngressPathPatchArray) ToHTTPIngressPathPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathPatchArrayOutput) } +func (i HTTPIngressPathPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPathPatch] { + return pulumix.Output[[]HTTPIngressPathPatch]{ + OutputState: i.ToHTTPIngressPathPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend. type HTTPIngressPathPatchOutput struct{ *pulumi.OutputState } @@ -267,6 +304,12 @@ func (o HTTPIngressPathPatchOutput) ToHTTPIngressPathPatchOutputWithContext(ctx return o } +func (o HTTPIngressPathPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPathPatch] { + return pulumix.Output[HTTPIngressPathPatch]{ + OutputState: o.OutputState, + } +} + // backend defines the referenced service endpoint to which the traffic will be forwarded to. func (o HTTPIngressPathPatchOutput) Backend() IngressBackendPatchPtrOutput { return o.ApplyT(func(v HTTPIngressPathPatch) *IngressBackendPatch { return v.Backend }).(IngressBackendPatchPtrOutput) @@ -307,6 +350,12 @@ func (o HTTPIngressPathPatchArrayOutput) ToHTTPIngressPathPatchArrayOutputWithCo return o } +func (o HTTPIngressPathPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPathPatch] { + return pulumix.Output[[]HTTPIngressPathPatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressPathPatchArrayOutput) Index(i pulumi.IntInput) HTTPIngressPathPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPIngressPathPatch { return vs[0].([]HTTPIngressPathPatch)[vs[1].(int)] @@ -348,6 +397,12 @@ func (i HTTPIngressRuleValueArgs) ToHTTPIngressRuleValueOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValueOutput) } +func (i HTTPIngressRuleValueArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValue] { + return pulumix.Output[HTTPIngressRuleValue]{ + OutputState: i.ToHTTPIngressRuleValueOutputWithContext(ctx).OutputState, + } +} + func (i HTTPIngressRuleValueArgs) ToHTTPIngressRuleValuePtrOutput() HTTPIngressRuleValuePtrOutput { return i.ToHTTPIngressRuleValuePtrOutputWithContext(context.Background()) } @@ -389,6 +444,12 @@ func (i *httpingressRuleValuePtrType) ToHTTPIngressRuleValuePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePtrOutput) } +func (i *httpingressRuleValuePtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValue] { + return pulumix.Output[*HTTPIngressRuleValue]{ + OutputState: i.ToHTTPIngressRuleValuePtrOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. type HTTPIngressRuleValueOutput struct{ *pulumi.OutputState } @@ -414,6 +475,12 @@ func (o HTTPIngressRuleValueOutput) ToHTTPIngressRuleValuePtrOutputWithContext(c }).(HTTPIngressRuleValuePtrOutput) } +func (o HTTPIngressRuleValueOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValue] { + return pulumix.Output[HTTPIngressRuleValue]{ + OutputState: o.OutputState, + } +} + // paths is a collection of paths that map requests to backends. func (o HTTPIngressRuleValueOutput) Paths() HTTPIngressPathArrayOutput { return o.ApplyT(func(v HTTPIngressRuleValue) []HTTPIngressPath { return v.Paths }).(HTTPIngressPathArrayOutput) @@ -433,6 +500,12 @@ func (o HTTPIngressRuleValuePtrOutput) ToHTTPIngressRuleValuePtrOutputWithContex return o } +func (o HTTPIngressRuleValuePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValue] { + return pulumix.Output[*HTTPIngressRuleValue]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressRuleValuePtrOutput) Elem() HTTPIngressRuleValueOutput { return o.ApplyT(func(v *HTTPIngressRuleValue) HTTPIngressRuleValue { if v != nil { @@ -488,6 +561,12 @@ func (i HTTPIngressRuleValuePatchArgs) ToHTTPIngressRuleValuePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePatchOutput) } +func (i HTTPIngressRuleValuePatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValuePatch] { + return pulumix.Output[HTTPIngressRuleValuePatch]{ + OutputState: i.ToHTTPIngressRuleValuePatchOutputWithContext(ctx).OutputState, + } +} + func (i HTTPIngressRuleValuePatchArgs) ToHTTPIngressRuleValuePatchPtrOutput() HTTPIngressRuleValuePatchPtrOutput { return i.ToHTTPIngressRuleValuePatchPtrOutputWithContext(context.Background()) } @@ -529,6 +608,12 @@ func (i *httpingressRuleValuePatchPtrType) ToHTTPIngressRuleValuePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePatchPtrOutput) } +func (i *httpingressRuleValuePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValuePatch] { + return pulumix.Output[*HTTPIngressRuleValuePatch]{ + OutputState: i.ToHTTPIngressRuleValuePatchPtrOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. type HTTPIngressRuleValuePatchOutput struct{ *pulumi.OutputState } @@ -554,6 +639,12 @@ func (o HTTPIngressRuleValuePatchOutput) ToHTTPIngressRuleValuePatchPtrOutputWit }).(HTTPIngressRuleValuePatchPtrOutput) } +func (o HTTPIngressRuleValuePatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValuePatch] { + return pulumix.Output[HTTPIngressRuleValuePatch]{ + OutputState: o.OutputState, + } +} + // paths is a collection of paths that map requests to backends. func (o HTTPIngressRuleValuePatchOutput) Paths() HTTPIngressPathPatchArrayOutput { return o.ApplyT(func(v HTTPIngressRuleValuePatch) []HTTPIngressPathPatch { return v.Paths }).(HTTPIngressPathPatchArrayOutput) @@ -573,6 +664,12 @@ func (o HTTPIngressRuleValuePatchPtrOutput) ToHTTPIngressRuleValuePatchPtrOutput return o } +func (o HTTPIngressRuleValuePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValuePatch] { + return pulumix.Output[*HTTPIngressRuleValuePatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressRuleValuePatchPtrOutput) Elem() HTTPIngressRuleValuePatchOutput { return o.ApplyT(func(v *HTTPIngressRuleValuePatch) HTTPIngressRuleValuePatch { if v != nil { @@ -632,6 +729,12 @@ func (i IPBlockArgs) ToIPBlockOutputWithContext(ctx context.Context) IPBlockOutp return pulumi.ToOutputWithContext(ctx, i).(IPBlockOutput) } +func (i IPBlockArgs) ToOutput(ctx context.Context) pulumix.Output[IPBlock] { + return pulumix.Output[IPBlock]{ + OutputState: i.ToIPBlockOutputWithContext(ctx).OutputState, + } +} + func (i IPBlockArgs) ToIPBlockPtrOutput() IPBlockPtrOutput { return i.ToIPBlockPtrOutputWithContext(context.Background()) } @@ -673,6 +776,12 @@ func (i *ipblockPtrType) ToIPBlockPtrOutputWithContext(ctx context.Context) IPBl return pulumi.ToOutputWithContext(ctx, i).(IPBlockPtrOutput) } +func (i *ipblockPtrType) ToOutput(ctx context.Context) pulumix.Output[*IPBlock] { + return pulumix.Output[*IPBlock]{ + OutputState: i.ToIPBlockPtrOutputWithContext(ctx).OutputState, + } +} + // IPBlock describes a particular CIDR (Ex. "192.168.1.0/24","2001:db8::/64") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule. type IPBlockOutput struct{ *pulumi.OutputState } @@ -698,6 +807,12 @@ func (o IPBlockOutput) ToIPBlockPtrOutputWithContext(ctx context.Context) IPBloc }).(IPBlockPtrOutput) } +func (o IPBlockOutput) ToOutput(ctx context.Context) pulumix.Output[IPBlock] { + return pulumix.Output[IPBlock]{ + OutputState: o.OutputState, + } +} + // cidr is a string representing the IPBlock Valid examples are "192.168.1.0/24" or "2001:db8::/64" func (o IPBlockOutput) Cidr() pulumi.StringOutput { return o.ApplyT(func(v IPBlock) string { return v.Cidr }).(pulumi.StringOutput) @@ -722,6 +837,12 @@ func (o IPBlockPtrOutput) ToIPBlockPtrOutputWithContext(ctx context.Context) IPB return o } +func (o IPBlockPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IPBlock] { + return pulumix.Output[*IPBlock]{ + OutputState: o.OutputState, + } +} + func (o IPBlockPtrOutput) Elem() IPBlockOutput { return o.ApplyT(func(v *IPBlock) IPBlock { if v != nil { @@ -791,6 +912,12 @@ func (i IPBlockPatchArgs) ToIPBlockPatchOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IPBlockPatchOutput) } +func (i IPBlockPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IPBlockPatch] { + return pulumix.Output[IPBlockPatch]{ + OutputState: i.ToIPBlockPatchOutputWithContext(ctx).OutputState, + } +} + func (i IPBlockPatchArgs) ToIPBlockPatchPtrOutput() IPBlockPatchPtrOutput { return i.ToIPBlockPatchPtrOutputWithContext(context.Background()) } @@ -832,6 +959,12 @@ func (i *ipblockPatchPtrType) ToIPBlockPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(IPBlockPatchPtrOutput) } +func (i *ipblockPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IPBlockPatch] { + return pulumix.Output[*IPBlockPatch]{ + OutputState: i.ToIPBlockPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IPBlock describes a particular CIDR (Ex. "192.168.1.0/24","2001:db8::/64") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule. type IPBlockPatchOutput struct{ *pulumi.OutputState } @@ -857,6 +990,12 @@ func (o IPBlockPatchOutput) ToIPBlockPatchPtrOutputWithContext(ctx context.Conte }).(IPBlockPatchPtrOutput) } +func (o IPBlockPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IPBlockPatch] { + return pulumix.Output[IPBlockPatch]{ + OutputState: o.OutputState, + } +} + // cidr is a string representing the IPBlock Valid examples are "192.168.1.0/24" or "2001:db8::/64" func (o IPBlockPatchOutput) Cidr() pulumi.StringPtrOutput { return o.ApplyT(func(v IPBlockPatch) *string { return v.Cidr }).(pulumi.StringPtrOutput) @@ -881,6 +1020,12 @@ func (o IPBlockPatchPtrOutput) ToIPBlockPatchPtrOutputWithContext(ctx context.Co return o } +func (o IPBlockPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IPBlockPatch] { + return pulumix.Output[*IPBlockPatch]{ + OutputState: o.OutputState, + } +} + func (o IPBlockPatchPtrOutput) Elem() IPBlockPatchOutput { return o.ApplyT(func(v *IPBlockPatch) IPBlockPatch { if v != nil { @@ -990,6 +1135,12 @@ func (i IngressTypeArgs) ToIngressTypeOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressTypeOutput) } +func (i IngressTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressType] { + return pulumix.Output[IngressType]{ + OutputState: i.ToIngressTypeOutputWithContext(ctx).OutputState, + } +} + // IngressTypeArrayInput is an input type that accepts IngressTypeArray and IngressTypeArrayOutput values. // You can construct a concrete instance of `IngressTypeArrayInput` via: // @@ -1015,6 +1166,12 @@ func (i IngressTypeArray) ToIngressTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressTypeArrayOutput) } +func (i IngressTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressType] { + return pulumix.Output[[]IngressType]{ + OutputState: i.ToIngressTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. // // This resource waits until its status is ready before registering success @@ -1044,6 +1201,12 @@ func (o IngressTypeOutput) ToIngressTypeOutputWithContext(ctx context.Context) I return o } +func (o IngressTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressType] { + return pulumix.Output[IngressType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1083,6 +1246,12 @@ func (o IngressTypeArrayOutput) ToIngressTypeArrayOutputWithContext(ctx context. return o } +func (o IngressTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressType] { + return pulumix.Output[[]IngressType]{ + OutputState: o.OutputState, + } +} + func (o IngressTypeArrayOutput) Index(i pulumi.IntInput) IngressTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressType { return vs[0].([]IngressType)[vs[1].(int)] @@ -1128,6 +1297,12 @@ func (i IngressBackendArgs) ToIngressBackendOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressBackendOutput) } +func (i IngressBackendArgs) ToOutput(ctx context.Context) pulumix.Output[IngressBackend] { + return pulumix.Output[IngressBackend]{ + OutputState: i.ToIngressBackendOutputWithContext(ctx).OutputState, + } +} + func (i IngressBackendArgs) ToIngressBackendPtrOutput() IngressBackendPtrOutput { return i.ToIngressBackendPtrOutputWithContext(context.Background()) } @@ -1169,6 +1344,12 @@ func (i *ingressBackendPtrType) ToIngressBackendPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPtrOutput) } +func (i *ingressBackendPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressBackend] { + return pulumix.Output[*IngressBackend]{ + OutputState: i.ToIngressBackendPtrOutputWithContext(ctx).OutputState, + } +} + // IngressBackend describes all endpoints for a given service and port. type IngressBackendOutput struct{ *pulumi.OutputState } @@ -1194,6 +1375,12 @@ func (o IngressBackendOutput) ToIngressBackendPtrOutputWithContext(ctx context.C }).(IngressBackendPtrOutput) } +func (o IngressBackendOutput) ToOutput(ctx context.Context) pulumix.Output[IngressBackend] { + return pulumix.Output[IngressBackend]{ + OutputState: o.OutputState, + } +} + // resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, a service.Name and service.Port must not be specified. This is a mutually exclusive setting with "Service". func (o IngressBackendOutput) Resource() corev1.TypedLocalObjectReferencePtrOutput { return o.ApplyT(func(v IngressBackend) *corev1.TypedLocalObjectReference { return v.Resource }).(corev1.TypedLocalObjectReferencePtrOutput) @@ -1218,6 +1405,12 @@ func (o IngressBackendPtrOutput) ToIngressBackendPtrOutputWithContext(ctx contex return o } +func (o IngressBackendPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressBackend] { + return pulumix.Output[*IngressBackend]{ + OutputState: o.OutputState, + } +} + func (o IngressBackendPtrOutput) Elem() IngressBackendOutput { return o.ApplyT(func(v *IngressBackend) IngressBackend { if v != nil { @@ -1287,6 +1480,12 @@ func (i IngressBackendPatchArgs) ToIngressBackendPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPatchOutput) } +func (i IngressBackendPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressBackendPatch] { + return pulumix.Output[IngressBackendPatch]{ + OutputState: i.ToIngressBackendPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressBackendPatchArgs) ToIngressBackendPatchPtrOutput() IngressBackendPatchPtrOutput { return i.ToIngressBackendPatchPtrOutputWithContext(context.Background()) } @@ -1328,6 +1527,12 @@ func (i *ingressBackendPatchPtrType) ToIngressBackendPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPatchPtrOutput) } +func (i *ingressBackendPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressBackendPatch] { + return pulumix.Output[*IngressBackendPatch]{ + OutputState: i.ToIngressBackendPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressBackend describes all endpoints for a given service and port. type IngressBackendPatchOutput struct{ *pulumi.OutputState } @@ -1353,6 +1558,12 @@ func (o IngressBackendPatchOutput) ToIngressBackendPatchPtrOutputWithContext(ctx }).(IngressBackendPatchPtrOutput) } +func (o IngressBackendPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressBackendPatch] { + return pulumix.Output[IngressBackendPatch]{ + OutputState: o.OutputState, + } +} + // resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, a service.Name and service.Port must not be specified. This is a mutually exclusive setting with "Service". func (o IngressBackendPatchOutput) Resource() corev1.TypedLocalObjectReferencePatchPtrOutput { return o.ApplyT(func(v IngressBackendPatch) *corev1.TypedLocalObjectReferencePatch { return v.Resource }).(corev1.TypedLocalObjectReferencePatchPtrOutput) @@ -1377,6 +1588,12 @@ func (o IngressBackendPatchPtrOutput) ToIngressBackendPatchPtrOutputWithContext( return o } +func (o IngressBackendPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressBackendPatch] { + return pulumix.Output[*IngressBackendPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressBackendPatchPtrOutput) Elem() IngressBackendPatchOutput { return o.ApplyT(func(v *IngressBackendPatch) IngressBackendPatch { if v != nil { @@ -1454,6 +1671,12 @@ func (i IngressClassTypeArgs) ToIngressClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressClassTypeOutput) } +func (i IngressClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassType] { + return pulumix.Output[IngressClassType]{ + OutputState: i.ToIngressClassTypeOutputWithContext(ctx).OutputState, + } +} + // IngressClassTypeArrayInput is an input type that accepts IngressClassTypeArray and IngressClassTypeArrayOutput values. // You can construct a concrete instance of `IngressClassTypeArrayInput` via: // @@ -1479,6 +1702,12 @@ func (i IngressClassTypeArray) ToIngressClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressClassTypeArrayOutput) } +func (i IngressClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressClassType] { + return pulumix.Output[[]IngressClassType]{ + OutputState: i.ToIngressClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. type IngressClassTypeOutput struct{ *pulumi.OutputState } @@ -1494,6 +1723,12 @@ func (o IngressClassTypeOutput) ToIngressClassTypeOutputWithContext(ctx context. return o } +func (o IngressClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassType] { + return pulumix.Output[IngressClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1528,6 +1763,12 @@ func (o IngressClassTypeArrayOutput) ToIngressClassTypeArrayOutputWithContext(ct return o } +func (o IngressClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressClassType] { + return pulumix.Output[[]IngressClassType]{ + OutputState: o.OutputState, + } +} + func (o IngressClassTypeArrayOutput) Index(i pulumi.IntInput) IngressClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressClassType { return vs[0].([]IngressClassType)[vs[1].(int)] @@ -1581,6 +1822,12 @@ func (i IngressClassListTypeArgs) ToIngressClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(IngressClassListTypeOutput) } +func (i IngressClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassListType] { + return pulumix.Output[IngressClassListType]{ + OutputState: i.ToIngressClassListTypeOutputWithContext(ctx).OutputState, + } +} + // IngressClassList is a collection of IngressClasses. type IngressClassListTypeOutput struct{ *pulumi.OutputState } @@ -1596,6 +1843,12 @@ func (o IngressClassListTypeOutput) ToIngressClassListTypeOutputWithContext(ctx return o } +func (o IngressClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassListType] { + return pulumix.Output[IngressClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1667,6 +1920,12 @@ func (i IngressClassParametersReferenceArgs) ToIngressClassParametersReferenceOu return pulumi.ToOutputWithContext(ctx, i).(IngressClassParametersReferenceOutput) } +func (i IngressClassParametersReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassParametersReference] { + return pulumix.Output[IngressClassParametersReference]{ + OutputState: i.ToIngressClassParametersReferenceOutputWithContext(ctx).OutputState, + } +} + func (i IngressClassParametersReferenceArgs) ToIngressClassParametersReferencePtrOutput() IngressClassParametersReferencePtrOutput { return i.ToIngressClassParametersReferencePtrOutputWithContext(context.Background()) } @@ -1708,6 +1967,12 @@ func (i *ingressClassParametersReferencePtrType) ToIngressClassParametersReferen return pulumi.ToOutputWithContext(ctx, i).(IngressClassParametersReferencePtrOutput) } +func (i *ingressClassParametersReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressClassParametersReference] { + return pulumix.Output[*IngressClassParametersReference]{ + OutputState: i.ToIngressClassParametersReferencePtrOutputWithContext(ctx).OutputState, + } +} + // IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource. type IngressClassParametersReferenceOutput struct{ *pulumi.OutputState } @@ -1733,6 +1998,12 @@ func (o IngressClassParametersReferenceOutput) ToIngressClassParametersReference }).(IngressClassParametersReferencePtrOutput) } +func (o IngressClassParametersReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassParametersReference] { + return pulumix.Output[IngressClassParametersReference]{ + OutputState: o.OutputState, + } +} + // apiGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. func (o IngressClassParametersReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassParametersReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1772,6 +2043,12 @@ func (o IngressClassParametersReferencePtrOutput) ToIngressClassParametersRefere return o } +func (o IngressClassParametersReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassParametersReference] { + return pulumix.Output[*IngressClassParametersReference]{ + OutputState: o.OutputState, + } +} + func (o IngressClassParametersReferencePtrOutput) Elem() IngressClassParametersReferenceOutput { return o.ApplyT(func(v *IngressClassParametersReference) IngressClassParametersReference { if v != nil { @@ -1883,6 +2160,12 @@ func (i IngressClassParametersReferencePatchArgs) ToIngressClassParametersRefere return pulumi.ToOutputWithContext(ctx, i).(IngressClassParametersReferencePatchOutput) } +func (i IngressClassParametersReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassParametersReferencePatch] { + return pulumix.Output[IngressClassParametersReferencePatch]{ + OutputState: i.ToIngressClassParametersReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressClassParametersReferencePatchArgs) ToIngressClassParametersReferencePatchPtrOutput() IngressClassParametersReferencePatchPtrOutput { return i.ToIngressClassParametersReferencePatchPtrOutputWithContext(context.Background()) } @@ -1924,6 +2207,12 @@ func (i *ingressClassParametersReferencePatchPtrType) ToIngressClassParametersRe return pulumi.ToOutputWithContext(ctx, i).(IngressClassParametersReferencePatchPtrOutput) } +func (i *ingressClassParametersReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressClassParametersReferencePatch] { + return pulumix.Output[*IngressClassParametersReferencePatch]{ + OutputState: i.ToIngressClassParametersReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource. type IngressClassParametersReferencePatchOutput struct{ *pulumi.OutputState } @@ -1949,6 +2238,12 @@ func (o IngressClassParametersReferencePatchOutput) ToIngressClassParametersRefe }).(IngressClassParametersReferencePatchPtrOutput) } +func (o IngressClassParametersReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassParametersReferencePatch] { + return pulumix.Output[IngressClassParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + // apiGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. func (o IngressClassParametersReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassParametersReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1988,6 +2283,12 @@ func (o IngressClassParametersReferencePatchPtrOutput) ToIngressClassParametersR return o } +func (o IngressClassParametersReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassParametersReferencePatch] { + return pulumix.Output[*IngressClassParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassParametersReferencePatchPtrOutput) Elem() IngressClassParametersReferencePatchOutput { return o.ApplyT(func(v *IngressClassParametersReferencePatch) IngressClassParametersReferencePatch { if v != nil { @@ -2095,6 +2396,12 @@ func (i IngressClassPatchTypeArgs) ToIngressClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchTypeOutput) } +func (i IngressClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassPatchType] { + return pulumix.Output[IngressClassPatchType]{ + OutputState: i.ToIngressClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. type IngressClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -2110,6 +2417,12 @@ func (o IngressClassPatchTypeOutput) ToIngressClassPatchTypeOutputWithContext(ct return o } +func (o IngressClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassPatchType] { + return pulumix.Output[IngressClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2169,6 +2482,12 @@ func (i IngressClassSpecArgs) ToIngressClassSpecOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecOutput) } +func (i IngressClassSpecArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpec] { + return pulumix.Output[IngressClassSpec]{ + OutputState: i.ToIngressClassSpecOutputWithContext(ctx).OutputState, + } +} + func (i IngressClassSpecArgs) ToIngressClassSpecPtrOutput() IngressClassSpecPtrOutput { return i.ToIngressClassSpecPtrOutputWithContext(context.Background()) } @@ -2210,6 +2529,12 @@ func (i *ingressClassSpecPtrType) ToIngressClassSpecPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecPtrOutput) } +func (i *ingressClassSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpec] { + return pulumix.Output[*IngressClassSpec]{ + OutputState: i.ToIngressClassSpecPtrOutputWithContext(ctx).OutputState, + } +} + // IngressClassSpec provides information about the class of an Ingress. type IngressClassSpecOutput struct{ *pulumi.OutputState } @@ -2235,6 +2560,12 @@ func (o IngressClassSpecOutput) ToIngressClassSpecPtrOutputWithContext(ctx conte }).(IngressClassSpecPtrOutput) } +func (o IngressClassSpecOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpec] { + return pulumix.Output[IngressClassSpec]{ + OutputState: o.OutputState, + } +} + // controller refers to the name of the controller that should handle this class. This allows for different "flavors" that are controlled by the same controller. For example, you may have different parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. "acme.io/ingress-controller". This field is immutable. func (o IngressClassSpecOutput) Controller() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassSpec) *string { return v.Controller }).(pulumi.StringPtrOutput) @@ -2259,6 +2590,12 @@ func (o IngressClassSpecPtrOutput) ToIngressClassSpecPtrOutputWithContext(ctx co return o } +func (o IngressClassSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpec] { + return pulumix.Output[*IngressClassSpec]{ + OutputState: o.OutputState, + } +} + func (o IngressClassSpecPtrOutput) Elem() IngressClassSpecOutput { return o.ApplyT(func(v *IngressClassSpec) IngressClassSpec { if v != nil { @@ -2328,6 +2665,12 @@ func (i IngressClassSpecPatchArgs) ToIngressClassSpecPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecPatchOutput) } +func (i IngressClassSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpecPatch] { + return pulumix.Output[IngressClassSpecPatch]{ + OutputState: i.ToIngressClassSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressClassSpecPatchArgs) ToIngressClassSpecPatchPtrOutput() IngressClassSpecPatchPtrOutput { return i.ToIngressClassSpecPatchPtrOutputWithContext(context.Background()) } @@ -2369,6 +2712,12 @@ func (i *ingressClassSpecPatchPtrType) ToIngressClassSpecPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecPatchPtrOutput) } +func (i *ingressClassSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpecPatch] { + return pulumix.Output[*IngressClassSpecPatch]{ + OutputState: i.ToIngressClassSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressClassSpec provides information about the class of an Ingress. type IngressClassSpecPatchOutput struct{ *pulumi.OutputState } @@ -2394,6 +2743,12 @@ func (o IngressClassSpecPatchOutput) ToIngressClassSpecPatchPtrOutputWithContext }).(IngressClassSpecPatchPtrOutput) } +func (o IngressClassSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpecPatch] { + return pulumix.Output[IngressClassSpecPatch]{ + OutputState: o.OutputState, + } +} + // controller refers to the name of the controller that should handle this class. This allows for different "flavors" that are controlled by the same controller. For example, you may have different parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. "acme.io/ingress-controller". This field is immutable. func (o IngressClassSpecPatchOutput) Controller() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassSpecPatch) *string { return v.Controller }).(pulumi.StringPtrOutput) @@ -2418,6 +2773,12 @@ func (o IngressClassSpecPatchPtrOutput) ToIngressClassSpecPatchPtrOutputWithCont return o } +func (o IngressClassSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpecPatch] { + return pulumix.Output[*IngressClassSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassSpecPatchPtrOutput) Elem() IngressClassSpecPatchOutput { return o.ApplyT(func(v *IngressClassSpecPatch) IngressClassSpecPatch { if v != nil { @@ -2495,6 +2856,12 @@ func (i IngressListTypeArgs) ToIngressListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressListTypeOutput) } +func (i IngressListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressListType] { + return pulumix.Output[IngressListType]{ + OutputState: i.ToIngressListTypeOutputWithContext(ctx).OutputState, + } +} + // IngressList is a collection of Ingress. type IngressListTypeOutput struct{ *pulumi.OutputState } @@ -2510,6 +2877,12 @@ func (o IngressListTypeOutput) ToIngressListTypeOutputWithContext(ctx context.Co return o } +func (o IngressListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressListType] { + return pulumix.Output[IngressListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2573,6 +2946,12 @@ func (i IngressLoadBalancerIngressArgs) ToIngressLoadBalancerIngressOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerIngressOutput) } +func (i IngressLoadBalancerIngressArgs) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerIngress] { + return pulumix.Output[IngressLoadBalancerIngress]{ + OutputState: i.ToIngressLoadBalancerIngressOutputWithContext(ctx).OutputState, + } +} + // IngressLoadBalancerIngressArrayInput is an input type that accepts IngressLoadBalancerIngressArray and IngressLoadBalancerIngressArrayOutput values. // You can construct a concrete instance of `IngressLoadBalancerIngressArrayInput` via: // @@ -2598,6 +2977,12 @@ func (i IngressLoadBalancerIngressArray) ToIngressLoadBalancerIngressArrayOutput return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerIngressArrayOutput) } +func (i IngressLoadBalancerIngressArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressLoadBalancerIngress] { + return pulumix.Output[[]IngressLoadBalancerIngress]{ + OutputState: i.ToIngressLoadBalancerIngressArrayOutputWithContext(ctx).OutputState, + } +} + // IngressLoadBalancerIngress represents the status of a load-balancer ingress point. type IngressLoadBalancerIngressOutput struct{ *pulumi.OutputState } @@ -2613,6 +2998,12 @@ func (o IngressLoadBalancerIngressOutput) ToIngressLoadBalancerIngressOutputWith return o } +func (o IngressLoadBalancerIngressOutput) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerIngress] { + return pulumix.Output[IngressLoadBalancerIngress]{ + OutputState: o.OutputState, + } +} + // hostname is set for load-balancer ingress points that are DNS based. func (o IngressLoadBalancerIngressOutput) Hostname() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressLoadBalancerIngress) *string { return v.Hostname }).(pulumi.StringPtrOutput) @@ -2642,6 +3033,12 @@ func (o IngressLoadBalancerIngressArrayOutput) ToIngressLoadBalancerIngressArray return o } +func (o IngressLoadBalancerIngressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressLoadBalancerIngress] { + return pulumix.Output[[]IngressLoadBalancerIngress]{ + OutputState: o.OutputState, + } +} + func (o IngressLoadBalancerIngressArrayOutput) Index(i pulumi.IntInput) IngressLoadBalancerIngressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressLoadBalancerIngress { return vs[0].([]IngressLoadBalancerIngress)[vs[1].(int)] @@ -2691,6 +3088,12 @@ func (i IngressLoadBalancerIngressPatchArgs) ToIngressLoadBalancerIngressPatchOu return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerIngressPatchOutput) } +func (i IngressLoadBalancerIngressPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerIngressPatch] { + return pulumix.Output[IngressLoadBalancerIngressPatch]{ + OutputState: i.ToIngressLoadBalancerIngressPatchOutputWithContext(ctx).OutputState, + } +} + // IngressLoadBalancerIngressPatchArrayInput is an input type that accepts IngressLoadBalancerIngressPatchArray and IngressLoadBalancerIngressPatchArrayOutput values. // You can construct a concrete instance of `IngressLoadBalancerIngressPatchArrayInput` via: // @@ -2716,6 +3119,12 @@ func (i IngressLoadBalancerIngressPatchArray) ToIngressLoadBalancerIngressPatchA return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerIngressPatchArrayOutput) } +func (i IngressLoadBalancerIngressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressLoadBalancerIngressPatch] { + return pulumix.Output[[]IngressLoadBalancerIngressPatch]{ + OutputState: i.ToIngressLoadBalancerIngressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressLoadBalancerIngress represents the status of a load-balancer ingress point. type IngressLoadBalancerIngressPatchOutput struct{ *pulumi.OutputState } @@ -2731,6 +3140,12 @@ func (o IngressLoadBalancerIngressPatchOutput) ToIngressLoadBalancerIngressPatch return o } +func (o IngressLoadBalancerIngressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerIngressPatch] { + return pulumix.Output[IngressLoadBalancerIngressPatch]{ + OutputState: o.OutputState, + } +} + // hostname is set for load-balancer ingress points that are DNS based. func (o IngressLoadBalancerIngressPatchOutput) Hostname() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressLoadBalancerIngressPatch) *string { return v.Hostname }).(pulumi.StringPtrOutput) @@ -2760,6 +3175,12 @@ func (o IngressLoadBalancerIngressPatchArrayOutput) ToIngressLoadBalancerIngress return o } +func (o IngressLoadBalancerIngressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressLoadBalancerIngressPatch] { + return pulumix.Output[[]IngressLoadBalancerIngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressLoadBalancerIngressPatchArrayOutput) Index(i pulumi.IntInput) IngressLoadBalancerIngressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressLoadBalancerIngressPatch { return vs[0].([]IngressLoadBalancerIngressPatch)[vs[1].(int)] @@ -2801,6 +3222,12 @@ func (i IngressLoadBalancerStatusArgs) ToIngressLoadBalancerStatusOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerStatusOutput) } +func (i IngressLoadBalancerStatusArgs) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerStatus] { + return pulumix.Output[IngressLoadBalancerStatus]{ + OutputState: i.ToIngressLoadBalancerStatusOutputWithContext(ctx).OutputState, + } +} + func (i IngressLoadBalancerStatusArgs) ToIngressLoadBalancerStatusPtrOutput() IngressLoadBalancerStatusPtrOutput { return i.ToIngressLoadBalancerStatusPtrOutputWithContext(context.Background()) } @@ -2842,6 +3269,12 @@ func (i *ingressLoadBalancerStatusPtrType) ToIngressLoadBalancerStatusPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerStatusPtrOutput) } +func (i *ingressLoadBalancerStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressLoadBalancerStatus] { + return pulumix.Output[*IngressLoadBalancerStatus]{ + OutputState: i.ToIngressLoadBalancerStatusPtrOutputWithContext(ctx).OutputState, + } +} + // IngressLoadBalancerStatus represents the status of a load-balancer. type IngressLoadBalancerStatusOutput struct{ *pulumi.OutputState } @@ -2867,6 +3300,12 @@ func (o IngressLoadBalancerStatusOutput) ToIngressLoadBalancerStatusPtrOutputWit }).(IngressLoadBalancerStatusPtrOutput) } +func (o IngressLoadBalancerStatusOutput) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerStatus] { + return pulumix.Output[IngressLoadBalancerStatus]{ + OutputState: o.OutputState, + } +} + // ingress is a list containing ingress points for the load-balancer. func (o IngressLoadBalancerStatusOutput) Ingress() IngressLoadBalancerIngressArrayOutput { return o.ApplyT(func(v IngressLoadBalancerStatus) []IngressLoadBalancerIngress { return v.Ingress }).(IngressLoadBalancerIngressArrayOutput) @@ -2886,6 +3325,12 @@ func (o IngressLoadBalancerStatusPtrOutput) ToIngressLoadBalancerStatusPtrOutput return o } +func (o IngressLoadBalancerStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressLoadBalancerStatus] { + return pulumix.Output[*IngressLoadBalancerStatus]{ + OutputState: o.OutputState, + } +} + func (o IngressLoadBalancerStatusPtrOutput) Elem() IngressLoadBalancerStatusOutput { return o.ApplyT(func(v *IngressLoadBalancerStatus) IngressLoadBalancerStatus { if v != nil { @@ -2941,6 +3386,12 @@ func (i IngressLoadBalancerStatusPatchArgs) ToIngressLoadBalancerStatusPatchOutp return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerStatusPatchOutput) } +func (i IngressLoadBalancerStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerStatusPatch] { + return pulumix.Output[IngressLoadBalancerStatusPatch]{ + OutputState: i.ToIngressLoadBalancerStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressLoadBalancerStatusPatchArgs) ToIngressLoadBalancerStatusPatchPtrOutput() IngressLoadBalancerStatusPatchPtrOutput { return i.ToIngressLoadBalancerStatusPatchPtrOutputWithContext(context.Background()) } @@ -2982,6 +3433,12 @@ func (i *ingressLoadBalancerStatusPatchPtrType) ToIngressLoadBalancerStatusPatch return pulumi.ToOutputWithContext(ctx, i).(IngressLoadBalancerStatusPatchPtrOutput) } +func (i *ingressLoadBalancerStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressLoadBalancerStatusPatch] { + return pulumix.Output[*IngressLoadBalancerStatusPatch]{ + OutputState: i.ToIngressLoadBalancerStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressLoadBalancerStatus represents the status of a load-balancer. type IngressLoadBalancerStatusPatchOutput struct{ *pulumi.OutputState } @@ -3007,6 +3464,12 @@ func (o IngressLoadBalancerStatusPatchOutput) ToIngressLoadBalancerStatusPatchPt }).(IngressLoadBalancerStatusPatchPtrOutput) } +func (o IngressLoadBalancerStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressLoadBalancerStatusPatch] { + return pulumix.Output[IngressLoadBalancerStatusPatch]{ + OutputState: o.OutputState, + } +} + // ingress is a list containing ingress points for the load-balancer. func (o IngressLoadBalancerStatusPatchOutput) Ingress() IngressLoadBalancerIngressPatchArrayOutput { return o.ApplyT(func(v IngressLoadBalancerStatusPatch) []IngressLoadBalancerIngressPatch { return v.Ingress }).(IngressLoadBalancerIngressPatchArrayOutput) @@ -3026,6 +3489,12 @@ func (o IngressLoadBalancerStatusPatchPtrOutput) ToIngressLoadBalancerStatusPatc return o } +func (o IngressLoadBalancerStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressLoadBalancerStatusPatch] { + return pulumix.Output[*IngressLoadBalancerStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressLoadBalancerStatusPatchPtrOutput) Elem() IngressLoadBalancerStatusPatchOutput { return o.ApplyT(func(v *IngressLoadBalancerStatusPatch) IngressLoadBalancerStatusPatch { if v != nil { @@ -3125,6 +3594,12 @@ func (i IngressPatchTypeArgs) ToIngressPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressPatchTypeOutput) } +func (i IngressPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressPatchType] { + return pulumix.Output[IngressPatchType]{ + OutputState: i.ToIngressPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. // // This resource waits until its status is ready before registering success @@ -3154,6 +3629,12 @@ func (o IngressPatchTypeOutput) ToIngressPatchTypeOutputWithContext(ctx context. return o } +func (o IngressPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressPatchType] { + return pulumix.Output[IngressPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3228,6 +3709,12 @@ func (i IngressPortStatusArgs) ToIngressPortStatusOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(IngressPortStatusOutput) } +func (i IngressPortStatusArgs) ToOutput(ctx context.Context) pulumix.Output[IngressPortStatus] { + return pulumix.Output[IngressPortStatus]{ + OutputState: i.ToIngressPortStatusOutputWithContext(ctx).OutputState, + } +} + // IngressPortStatusArrayInput is an input type that accepts IngressPortStatusArray and IngressPortStatusArrayOutput values. // You can construct a concrete instance of `IngressPortStatusArrayInput` via: // @@ -3253,6 +3740,12 @@ func (i IngressPortStatusArray) ToIngressPortStatusArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(IngressPortStatusArrayOutput) } +func (i IngressPortStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressPortStatus] { + return pulumix.Output[[]IngressPortStatus]{ + OutputState: i.ToIngressPortStatusArrayOutputWithContext(ctx).OutputState, + } +} + // IngressPortStatus represents the error condition of a service port type IngressPortStatusOutput struct{ *pulumi.OutputState } @@ -3268,6 +3761,12 @@ func (o IngressPortStatusOutput) ToIngressPortStatusOutputWithContext(ctx contex return o } +func (o IngressPortStatusOutput) ToOutput(ctx context.Context) pulumix.Output[IngressPortStatus] { + return pulumix.Output[IngressPortStatus]{ + OutputState: o.OutputState, + } +} + // error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use // // CamelCase names @@ -3301,6 +3800,12 @@ func (o IngressPortStatusArrayOutput) ToIngressPortStatusArrayOutputWithContext( return o } +func (o IngressPortStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressPortStatus] { + return pulumix.Output[[]IngressPortStatus]{ + OutputState: o.OutputState, + } +} + func (o IngressPortStatusArrayOutput) Index(i pulumi.IntInput) IngressPortStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressPortStatus { return vs[0].([]IngressPortStatus)[vs[1].(int)] @@ -3356,6 +3861,12 @@ func (i IngressPortStatusPatchArgs) ToIngressPortStatusPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(IngressPortStatusPatchOutput) } +func (i IngressPortStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressPortStatusPatch] { + return pulumix.Output[IngressPortStatusPatch]{ + OutputState: i.ToIngressPortStatusPatchOutputWithContext(ctx).OutputState, + } +} + // IngressPortStatusPatchArrayInput is an input type that accepts IngressPortStatusPatchArray and IngressPortStatusPatchArrayOutput values. // You can construct a concrete instance of `IngressPortStatusPatchArrayInput` via: // @@ -3381,6 +3892,12 @@ func (i IngressPortStatusPatchArray) ToIngressPortStatusPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(IngressPortStatusPatchArrayOutput) } +func (i IngressPortStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressPortStatusPatch] { + return pulumix.Output[[]IngressPortStatusPatch]{ + OutputState: i.ToIngressPortStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressPortStatus represents the error condition of a service port type IngressPortStatusPatchOutput struct{ *pulumi.OutputState } @@ -3396,6 +3913,12 @@ func (o IngressPortStatusPatchOutput) ToIngressPortStatusPatchOutputWithContext( return o } +func (o IngressPortStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressPortStatusPatch] { + return pulumix.Output[IngressPortStatusPatch]{ + OutputState: o.OutputState, + } +} + // error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use // // CamelCase names @@ -3429,6 +3952,12 @@ func (o IngressPortStatusPatchArrayOutput) ToIngressPortStatusPatchArrayOutputWi return o } +func (o IngressPortStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressPortStatusPatch] { + return pulumix.Output[[]IngressPortStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPortStatusPatchArrayOutput) Index(i pulumi.IntInput) IngressPortStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressPortStatusPatch { return vs[0].([]IngressPortStatusPatch)[vs[1].(int)] @@ -3486,6 +4015,12 @@ func (i IngressRuleArgs) ToIngressRuleOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressRuleOutput) } +func (i IngressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[IngressRule] { + return pulumix.Output[IngressRule]{ + OutputState: i.ToIngressRuleOutputWithContext(ctx).OutputState, + } +} + // IngressRuleArrayInput is an input type that accepts IngressRuleArray and IngressRuleArrayOutput values. // You can construct a concrete instance of `IngressRuleArrayInput` via: // @@ -3511,6 +4046,12 @@ func (i IngressRuleArray) ToIngressRuleArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressRuleArrayOutput) } +func (i IngressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressRule] { + return pulumix.Output[[]IngressRule]{ + OutputState: i.ToIngressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. type IngressRuleOutput struct{ *pulumi.OutputState } @@ -3526,6 +4067,12 @@ func (o IngressRuleOutput) ToIngressRuleOutputWithContext(ctx context.Context) I return o } +func (o IngressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[IngressRule] { + return pulumix.Output[IngressRule]{ + OutputState: o.OutputState, + } +} + // host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to // // the IP in the Spec of the parent Ingress. @@ -3558,6 +4105,12 @@ func (o IngressRuleArrayOutput) ToIngressRuleArrayOutputWithContext(ctx context. return o } +func (o IngressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressRule] { + return pulumix.Output[[]IngressRule]{ + OutputState: o.OutputState, + } +} + func (o IngressRuleArrayOutput) Index(i pulumi.IntInput) IngressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressRule { return vs[0].([]IngressRule)[vs[1].(int)] @@ -3615,6 +4168,12 @@ func (i IngressRulePatchArgs) ToIngressRulePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressRulePatchOutput) } +func (i IngressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressRulePatch] { + return pulumix.Output[IngressRulePatch]{ + OutputState: i.ToIngressRulePatchOutputWithContext(ctx).OutputState, + } +} + // IngressRulePatchArrayInput is an input type that accepts IngressRulePatchArray and IngressRulePatchArrayOutput values. // You can construct a concrete instance of `IngressRulePatchArrayInput` via: // @@ -3640,6 +4199,12 @@ func (i IngressRulePatchArray) ToIngressRulePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressRulePatchArrayOutput) } +func (i IngressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressRulePatch] { + return pulumix.Output[[]IngressRulePatch]{ + OutputState: i.ToIngressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. type IngressRulePatchOutput struct{ *pulumi.OutputState } @@ -3655,6 +4220,12 @@ func (o IngressRulePatchOutput) ToIngressRulePatchOutputWithContext(ctx context. return o } +func (o IngressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressRulePatch] { + return pulumix.Output[IngressRulePatch]{ + OutputState: o.OutputState, + } +} + // host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to // // the IP in the Spec of the parent Ingress. @@ -3687,6 +4258,12 @@ func (o IngressRulePatchArrayOutput) ToIngressRulePatchArrayOutputWithContext(ct return o } +func (o IngressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressRulePatch] { + return pulumix.Output[[]IngressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o IngressRulePatchArrayOutput) Index(i pulumi.IntInput) IngressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressRulePatch { return vs[0].([]IngressRulePatch)[vs[1].(int)] @@ -3732,6 +4309,12 @@ func (i IngressServiceBackendArgs) ToIngressServiceBackendOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressServiceBackendOutput) } +func (i IngressServiceBackendArgs) ToOutput(ctx context.Context) pulumix.Output[IngressServiceBackend] { + return pulumix.Output[IngressServiceBackend]{ + OutputState: i.ToIngressServiceBackendOutputWithContext(ctx).OutputState, + } +} + func (i IngressServiceBackendArgs) ToIngressServiceBackendPtrOutput() IngressServiceBackendPtrOutput { return i.ToIngressServiceBackendPtrOutputWithContext(context.Background()) } @@ -3773,6 +4356,12 @@ func (i *ingressServiceBackendPtrType) ToIngressServiceBackendPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(IngressServiceBackendPtrOutput) } +func (i *ingressServiceBackendPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressServiceBackend] { + return pulumix.Output[*IngressServiceBackend]{ + OutputState: i.ToIngressServiceBackendPtrOutputWithContext(ctx).OutputState, + } +} + // IngressServiceBackend references a Kubernetes Service as a Backend. type IngressServiceBackendOutput struct{ *pulumi.OutputState } @@ -3798,6 +4387,12 @@ func (o IngressServiceBackendOutput) ToIngressServiceBackendPtrOutputWithContext }).(IngressServiceBackendPtrOutput) } +func (o IngressServiceBackendOutput) ToOutput(ctx context.Context) pulumix.Output[IngressServiceBackend] { + return pulumix.Output[IngressServiceBackend]{ + OutputState: o.OutputState, + } +} + // name is the referenced service. The service must exist in the same namespace as the Ingress object. func (o IngressServiceBackendOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v IngressServiceBackend) string { return v.Name }).(pulumi.StringOutput) @@ -3822,6 +4417,12 @@ func (o IngressServiceBackendPtrOutput) ToIngressServiceBackendPtrOutputWithCont return o } +func (o IngressServiceBackendPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressServiceBackend] { + return pulumix.Output[*IngressServiceBackend]{ + OutputState: o.OutputState, + } +} + func (o IngressServiceBackendPtrOutput) Elem() IngressServiceBackendOutput { return o.ApplyT(func(v *IngressServiceBackend) IngressServiceBackend { if v != nil { @@ -3891,6 +4492,12 @@ func (i IngressServiceBackendPatchArgs) ToIngressServiceBackendPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(IngressServiceBackendPatchOutput) } +func (i IngressServiceBackendPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressServiceBackendPatch] { + return pulumix.Output[IngressServiceBackendPatch]{ + OutputState: i.ToIngressServiceBackendPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressServiceBackendPatchArgs) ToIngressServiceBackendPatchPtrOutput() IngressServiceBackendPatchPtrOutput { return i.ToIngressServiceBackendPatchPtrOutputWithContext(context.Background()) } @@ -3932,6 +4539,12 @@ func (i *ingressServiceBackendPatchPtrType) ToIngressServiceBackendPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(IngressServiceBackendPatchPtrOutput) } +func (i *ingressServiceBackendPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressServiceBackendPatch] { + return pulumix.Output[*IngressServiceBackendPatch]{ + OutputState: i.ToIngressServiceBackendPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressServiceBackend references a Kubernetes Service as a Backend. type IngressServiceBackendPatchOutput struct{ *pulumi.OutputState } @@ -3957,6 +4570,12 @@ func (o IngressServiceBackendPatchOutput) ToIngressServiceBackendPatchPtrOutputW }).(IngressServiceBackendPatchPtrOutput) } +func (o IngressServiceBackendPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressServiceBackendPatch] { + return pulumix.Output[IngressServiceBackendPatch]{ + OutputState: o.OutputState, + } +} + // name is the referenced service. The service must exist in the same namespace as the Ingress object. func (o IngressServiceBackendPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressServiceBackendPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -3981,6 +4600,12 @@ func (o IngressServiceBackendPatchPtrOutput) ToIngressServiceBackendPatchPtrOutp return o } +func (o IngressServiceBackendPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressServiceBackendPatch] { + return pulumix.Output[*IngressServiceBackendPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressServiceBackendPatchPtrOutput) Elem() IngressServiceBackendPatchOutput { return o.ApplyT(func(v *IngressServiceBackendPatch) IngressServiceBackendPatch { if v != nil { @@ -4058,6 +4683,12 @@ func (i IngressSpecArgs) ToIngressSpecOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressSpecOutput) } +func (i IngressSpecArgs) ToOutput(ctx context.Context) pulumix.Output[IngressSpec] { + return pulumix.Output[IngressSpec]{ + OutputState: i.ToIngressSpecOutputWithContext(ctx).OutputState, + } +} + func (i IngressSpecArgs) ToIngressSpecPtrOutput() IngressSpecPtrOutput { return i.ToIngressSpecPtrOutputWithContext(context.Background()) } @@ -4099,6 +4730,12 @@ func (i *ingressSpecPtrType) ToIngressSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPtrOutput) } +func (i *ingressSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressSpec] { + return pulumix.Output[*IngressSpec]{ + OutputState: i.ToIngressSpecPtrOutputWithContext(ctx).OutputState, + } +} + // IngressSpec describes the Ingress the user wishes to exist. type IngressSpecOutput struct{ *pulumi.OutputState } @@ -4124,6 +4761,12 @@ func (o IngressSpecOutput) ToIngressSpecPtrOutputWithContext(ctx context.Context }).(IngressSpecPtrOutput) } +func (o IngressSpecOutput) ToOutput(ctx context.Context) pulumix.Output[IngressSpec] { + return pulumix.Output[IngressSpec]{ + OutputState: o.OutputState, + } +} + // defaultBackend is the backend that should handle requests that don't match any rule. If Rules are not specified, DefaultBackend must be specified. If DefaultBackend is not set, the handling of requests that do not match any of the rules will be up to the Ingress controller. func (o IngressSpecOutput) DefaultBackend() IngressBackendPtrOutput { return o.ApplyT(func(v IngressSpec) *IngressBackend { return v.DefaultBackend }).(IngressBackendPtrOutput) @@ -4158,6 +4801,12 @@ func (o IngressSpecPtrOutput) ToIngressSpecPtrOutputWithContext(ctx context.Cont return o } +func (o IngressSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressSpec] { + return pulumix.Output[*IngressSpec]{ + OutputState: o.OutputState, + } +} + func (o IngressSpecPtrOutput) Elem() IngressSpecOutput { return o.ApplyT(func(v *IngressSpec) IngressSpec { if v != nil { @@ -4255,6 +4904,12 @@ func (i IngressSpecPatchArgs) ToIngressSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPatchOutput) } +func (i IngressSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressSpecPatch] { + return pulumix.Output[IngressSpecPatch]{ + OutputState: i.ToIngressSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressSpecPatchArgs) ToIngressSpecPatchPtrOutput() IngressSpecPatchPtrOutput { return i.ToIngressSpecPatchPtrOutputWithContext(context.Background()) } @@ -4296,6 +4951,12 @@ func (i *ingressSpecPatchPtrType) ToIngressSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPatchPtrOutput) } +func (i *ingressSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressSpecPatch] { + return pulumix.Output[*IngressSpecPatch]{ + OutputState: i.ToIngressSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressSpec describes the Ingress the user wishes to exist. type IngressSpecPatchOutput struct{ *pulumi.OutputState } @@ -4321,6 +4982,12 @@ func (o IngressSpecPatchOutput) ToIngressSpecPatchPtrOutputWithContext(ctx conte }).(IngressSpecPatchPtrOutput) } +func (o IngressSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressSpecPatch] { + return pulumix.Output[IngressSpecPatch]{ + OutputState: o.OutputState, + } +} + // defaultBackend is the backend that should handle requests that don't match any rule. If Rules are not specified, DefaultBackend must be specified. If DefaultBackend is not set, the handling of requests that do not match any of the rules will be up to the Ingress controller. func (o IngressSpecPatchOutput) DefaultBackend() IngressBackendPatchPtrOutput { return o.ApplyT(func(v IngressSpecPatch) *IngressBackendPatch { return v.DefaultBackend }).(IngressBackendPatchPtrOutput) @@ -4355,6 +5022,12 @@ func (o IngressSpecPatchPtrOutput) ToIngressSpecPatchPtrOutputWithContext(ctx co return o } +func (o IngressSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressSpecPatch] { + return pulumix.Output[*IngressSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressSpecPatchPtrOutput) Elem() IngressSpecPatchOutput { return o.ApplyT(func(v *IngressSpecPatch) IngressSpecPatch { if v != nil { @@ -4440,6 +5113,12 @@ func (i IngressStatusArgs) ToIngressStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressStatusOutput) } +func (i IngressStatusArgs) ToOutput(ctx context.Context) pulumix.Output[IngressStatus] { + return pulumix.Output[IngressStatus]{ + OutputState: i.ToIngressStatusOutputWithContext(ctx).OutputState, + } +} + func (i IngressStatusArgs) ToIngressStatusPtrOutput() IngressStatusPtrOutput { return i.ToIngressStatusPtrOutputWithContext(context.Background()) } @@ -4481,6 +5160,12 @@ func (i *ingressStatusPtrType) ToIngressStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPtrOutput) } +func (i *ingressStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressStatus] { + return pulumix.Output[*IngressStatus]{ + OutputState: i.ToIngressStatusPtrOutputWithContext(ctx).OutputState, + } +} + // IngressStatus describe the current state of the Ingress. type IngressStatusOutput struct{ *pulumi.OutputState } @@ -4506,6 +5191,12 @@ func (o IngressStatusOutput) ToIngressStatusPtrOutputWithContext(ctx context.Con }).(IngressStatusPtrOutput) } +func (o IngressStatusOutput) ToOutput(ctx context.Context) pulumix.Output[IngressStatus] { + return pulumix.Output[IngressStatus]{ + OutputState: o.OutputState, + } +} + // loadBalancer contains the current status of the load-balancer. func (o IngressStatusOutput) LoadBalancer() IngressLoadBalancerStatusPtrOutput { return o.ApplyT(func(v IngressStatus) *IngressLoadBalancerStatus { return v.LoadBalancer }).(IngressLoadBalancerStatusPtrOutput) @@ -4525,6 +5216,12 @@ func (o IngressStatusPtrOutput) ToIngressStatusPtrOutputWithContext(ctx context. return o } +func (o IngressStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressStatus] { + return pulumix.Output[*IngressStatus]{ + OutputState: o.OutputState, + } +} + func (o IngressStatusPtrOutput) Elem() IngressStatusOutput { return o.ApplyT(func(v *IngressStatus) IngressStatus { if v != nil { @@ -4580,6 +5277,12 @@ func (i IngressStatusPatchArgs) ToIngressStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPatchOutput) } +func (i IngressStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressStatusPatch] { + return pulumix.Output[IngressStatusPatch]{ + OutputState: i.ToIngressStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressStatusPatchArgs) ToIngressStatusPatchPtrOutput() IngressStatusPatchPtrOutput { return i.ToIngressStatusPatchPtrOutputWithContext(context.Background()) } @@ -4621,6 +5324,12 @@ func (i *ingressStatusPatchPtrType) ToIngressStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPatchPtrOutput) } +func (i *ingressStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressStatusPatch] { + return pulumix.Output[*IngressStatusPatch]{ + OutputState: i.ToIngressStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressStatus describe the current state of the Ingress. type IngressStatusPatchOutput struct{ *pulumi.OutputState } @@ -4646,6 +5355,12 @@ func (o IngressStatusPatchOutput) ToIngressStatusPatchPtrOutputWithContext(ctx c }).(IngressStatusPatchPtrOutput) } +func (o IngressStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressStatusPatch] { + return pulumix.Output[IngressStatusPatch]{ + OutputState: o.OutputState, + } +} + // loadBalancer contains the current status of the load-balancer. func (o IngressStatusPatchOutput) LoadBalancer() IngressLoadBalancerStatusPatchPtrOutput { return o.ApplyT(func(v IngressStatusPatch) *IngressLoadBalancerStatusPatch { return v.LoadBalancer }).(IngressLoadBalancerStatusPatchPtrOutput) @@ -4665,6 +5380,12 @@ func (o IngressStatusPatchPtrOutput) ToIngressStatusPatchPtrOutputWithContext(ct return o } +func (o IngressStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressStatusPatch] { + return pulumix.Output[*IngressStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressStatusPatchPtrOutput) Elem() IngressStatusPatchOutput { return o.ApplyT(func(v *IngressStatusPatch) IngressStatusPatch { if v != nil { @@ -4724,6 +5445,12 @@ func (i IngressTLSArgs) ToIngressTLSOutputWithContext(ctx context.Context) Ingre return pulumi.ToOutputWithContext(ctx, i).(IngressTLSOutput) } +func (i IngressTLSArgs) ToOutput(ctx context.Context) pulumix.Output[IngressTLS] { + return pulumix.Output[IngressTLS]{ + OutputState: i.ToIngressTLSOutputWithContext(ctx).OutputState, + } +} + // IngressTLSArrayInput is an input type that accepts IngressTLSArray and IngressTLSArrayOutput values. // You can construct a concrete instance of `IngressTLSArrayInput` via: // @@ -4749,6 +5476,12 @@ func (i IngressTLSArray) ToIngressTLSArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressTLSArrayOutput) } +func (i IngressTLSArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLS] { + return pulumix.Output[[]IngressTLS]{ + OutputState: i.ToIngressTLSArrayOutputWithContext(ctx).OutputState, + } +} + // IngressTLS describes the transport layer security associated with an ingress. type IngressTLSOutput struct{ *pulumi.OutputState } @@ -4764,6 +5497,12 @@ func (o IngressTLSOutput) ToIngressTLSOutputWithContext(ctx context.Context) Ing return o } +func (o IngressTLSOutput) ToOutput(ctx context.Context) pulumix.Output[IngressTLS] { + return pulumix.Output[IngressTLS]{ + OutputState: o.OutputState, + } +} + // hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. func (o IngressTLSOutput) Hosts() pulumi.StringArrayOutput { return o.ApplyT(func(v IngressTLS) []string { return v.Hosts }).(pulumi.StringArrayOutput) @@ -4788,6 +5527,12 @@ func (o IngressTLSArrayOutput) ToIngressTLSArrayOutputWithContext(ctx context.Co return o } +func (o IngressTLSArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLS] { + return pulumix.Output[[]IngressTLS]{ + OutputState: o.OutputState, + } +} + func (o IngressTLSArrayOutput) Index(i pulumi.IntInput) IngressTLSOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressTLS { return vs[0].([]IngressTLS)[vs[1].(int)] @@ -4833,6 +5578,12 @@ func (i IngressTLSPatchArgs) ToIngressTLSPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressTLSPatchOutput) } +func (i IngressTLSPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressTLSPatch] { + return pulumix.Output[IngressTLSPatch]{ + OutputState: i.ToIngressTLSPatchOutputWithContext(ctx).OutputState, + } +} + // IngressTLSPatchArrayInput is an input type that accepts IngressTLSPatchArray and IngressTLSPatchArrayOutput values. // You can construct a concrete instance of `IngressTLSPatchArrayInput` via: // @@ -4858,6 +5609,12 @@ func (i IngressTLSPatchArray) ToIngressTLSPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressTLSPatchArrayOutput) } +func (i IngressTLSPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLSPatch] { + return pulumix.Output[[]IngressTLSPatch]{ + OutputState: i.ToIngressTLSPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressTLS describes the transport layer security associated with an ingress. type IngressTLSPatchOutput struct{ *pulumi.OutputState } @@ -4873,6 +5630,12 @@ func (o IngressTLSPatchOutput) ToIngressTLSPatchOutputWithContext(ctx context.Co return o } +func (o IngressTLSPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressTLSPatch] { + return pulumix.Output[IngressTLSPatch]{ + OutputState: o.OutputState, + } +} + // hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. func (o IngressTLSPatchOutput) Hosts() pulumi.StringArrayOutput { return o.ApplyT(func(v IngressTLSPatch) []string { return v.Hosts }).(pulumi.StringArrayOutput) @@ -4897,6 +5660,12 @@ func (o IngressTLSPatchArrayOutput) ToIngressTLSPatchArrayOutputWithContext(ctx return o } +func (o IngressTLSPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLSPatch] { + return pulumix.Output[[]IngressTLSPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressTLSPatchArrayOutput) Index(i pulumi.IntInput) IngressTLSPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressTLSPatch { return vs[0].([]IngressTLSPatch)[vs[1].(int)] @@ -4954,6 +5723,12 @@ func (i NetworkPolicyTypeArgs) ToNetworkPolicyTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyTypeOutput) } +func (i NetworkPolicyTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyType] { + return pulumix.Output[NetworkPolicyType]{ + OutputState: i.ToNetworkPolicyTypeOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyTypeArrayInput is an input type that accepts NetworkPolicyTypeArray and NetworkPolicyTypeArrayOutput values. // You can construct a concrete instance of `NetworkPolicyTypeArrayInput` via: // @@ -4979,6 +5754,12 @@ func (i NetworkPolicyTypeArray) ToNetworkPolicyTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyTypeArrayOutput) } +func (i NetworkPolicyTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyType] { + return pulumix.Output[[]NetworkPolicyType]{ + OutputState: i.ToNetworkPolicyTypeArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicy describes what network traffic is allowed for a set of Pods type NetworkPolicyTypeOutput struct{ *pulumi.OutputState } @@ -4994,6 +5775,12 @@ func (o NetworkPolicyTypeOutput) ToNetworkPolicyTypeOutputWithContext(ctx contex return o } +func (o NetworkPolicyTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyType] { + return pulumix.Output[NetworkPolicyType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NetworkPolicyType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5033,6 +5820,12 @@ func (o NetworkPolicyTypeArrayOutput) ToNetworkPolicyTypeArrayOutputWithContext( return o } +func (o NetworkPolicyTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyType] { + return pulumix.Output[[]NetworkPolicyType]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyTypeArrayOutput) Index(i pulumi.IntInput) NetworkPolicyTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyType { return vs[0].([]NetworkPolicyType)[vs[1].(int)] @@ -5078,6 +5871,12 @@ func (i NetworkPolicyEgressRuleArgs) ToNetworkPolicyEgressRuleOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRuleOutput) } +func (i NetworkPolicyEgressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRule] { + return pulumix.Output[NetworkPolicyEgressRule]{ + OutputState: i.ToNetworkPolicyEgressRuleOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyEgressRuleArrayInput is an input type that accepts NetworkPolicyEgressRuleArray and NetworkPolicyEgressRuleArrayOutput values. // You can construct a concrete instance of `NetworkPolicyEgressRuleArrayInput` via: // @@ -5103,6 +5902,12 @@ func (i NetworkPolicyEgressRuleArray) ToNetworkPolicyEgressRuleArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRuleArrayOutput) } +func (i NetworkPolicyEgressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRule] { + return pulumix.Output[[]NetworkPolicyEgressRule]{ + OutputState: i.ToNetworkPolicyEgressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 type NetworkPolicyEgressRuleOutput struct{ *pulumi.OutputState } @@ -5118,6 +5923,12 @@ func (o NetworkPolicyEgressRuleOutput) ToNetworkPolicyEgressRuleOutputWithContex return o } +func (o NetworkPolicyEgressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRule] { + return pulumix.Output[NetworkPolicyEgressRule]{ + OutputState: o.OutputState, + } +} + // ports is a list of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. func (o NetworkPolicyEgressRuleOutput) Ports() NetworkPolicyPortArrayOutput { return o.ApplyT(func(v NetworkPolicyEgressRule) []NetworkPolicyPort { return v.Ports }).(NetworkPolicyPortArrayOutput) @@ -5142,6 +5953,12 @@ func (o NetworkPolicyEgressRuleArrayOutput) ToNetworkPolicyEgressRuleArrayOutput return o } +func (o NetworkPolicyEgressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRule] { + return pulumix.Output[[]NetworkPolicyEgressRule]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyEgressRuleArrayOutput) Index(i pulumi.IntInput) NetworkPolicyEgressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyEgressRule { return vs[0].([]NetworkPolicyEgressRule)[vs[1].(int)] @@ -5187,6 +6004,12 @@ func (i NetworkPolicyEgressRulePatchArgs) ToNetworkPolicyEgressRulePatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRulePatchOutput) } +func (i NetworkPolicyEgressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRulePatch] { + return pulumix.Output[NetworkPolicyEgressRulePatch]{ + OutputState: i.ToNetworkPolicyEgressRulePatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyEgressRulePatchArrayInput is an input type that accepts NetworkPolicyEgressRulePatchArray and NetworkPolicyEgressRulePatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyEgressRulePatchArrayInput` via: // @@ -5212,6 +6035,12 @@ func (i NetworkPolicyEgressRulePatchArray) ToNetworkPolicyEgressRulePatchArrayOu return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyEgressRulePatchArrayOutput) } +func (i NetworkPolicyEgressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRulePatch] { + return pulumix.Output[[]NetworkPolicyEgressRulePatch]{ + OutputState: i.ToNetworkPolicyEgressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 type NetworkPolicyEgressRulePatchOutput struct{ *pulumi.OutputState } @@ -5227,6 +6056,12 @@ func (o NetworkPolicyEgressRulePatchOutput) ToNetworkPolicyEgressRulePatchOutput return o } +func (o NetworkPolicyEgressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyEgressRulePatch] { + return pulumix.Output[NetworkPolicyEgressRulePatch]{ + OutputState: o.OutputState, + } +} + // ports is a list of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. func (o NetworkPolicyEgressRulePatchOutput) Ports() NetworkPolicyPortPatchArrayOutput { return o.ApplyT(func(v NetworkPolicyEgressRulePatch) []NetworkPolicyPortPatch { return v.Ports }).(NetworkPolicyPortPatchArrayOutput) @@ -5251,6 +6086,12 @@ func (o NetworkPolicyEgressRulePatchArrayOutput) ToNetworkPolicyEgressRulePatchA return o } +func (o NetworkPolicyEgressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyEgressRulePatch] { + return pulumix.Output[[]NetworkPolicyEgressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyEgressRulePatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyEgressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyEgressRulePatch { return vs[0].([]NetworkPolicyEgressRulePatch)[vs[1].(int)] @@ -5296,6 +6137,12 @@ func (i NetworkPolicyIngressRuleArgs) ToNetworkPolicyIngressRuleOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRuleOutput) } +func (i NetworkPolicyIngressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRule] { + return pulumix.Output[NetworkPolicyIngressRule]{ + OutputState: i.ToNetworkPolicyIngressRuleOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyIngressRuleArrayInput is an input type that accepts NetworkPolicyIngressRuleArray and NetworkPolicyIngressRuleArrayOutput values. // You can construct a concrete instance of `NetworkPolicyIngressRuleArrayInput` via: // @@ -5321,6 +6168,12 @@ func (i NetworkPolicyIngressRuleArray) ToNetworkPolicyIngressRuleArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRuleArrayOutput) } +func (i NetworkPolicyIngressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRule] { + return pulumix.Output[[]NetworkPolicyIngressRule]{ + OutputState: i.ToNetworkPolicyIngressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from. type NetworkPolicyIngressRuleOutput struct{ *pulumi.OutputState } @@ -5336,6 +6189,12 @@ func (o NetworkPolicyIngressRuleOutput) ToNetworkPolicyIngressRuleOutputWithCont return o } +func (o NetworkPolicyIngressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRule] { + return pulumix.Output[NetworkPolicyIngressRule]{ + OutputState: o.OutputState, + } +} + // from is a list of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. func (o NetworkPolicyIngressRuleOutput) From() NetworkPolicyPeerArrayOutput { return o.ApplyT(func(v NetworkPolicyIngressRule) []NetworkPolicyPeer { return v.From }).(NetworkPolicyPeerArrayOutput) @@ -5360,6 +6219,12 @@ func (o NetworkPolicyIngressRuleArrayOutput) ToNetworkPolicyIngressRuleArrayOutp return o } +func (o NetworkPolicyIngressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRule] { + return pulumix.Output[[]NetworkPolicyIngressRule]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyIngressRuleArrayOutput) Index(i pulumi.IntInput) NetworkPolicyIngressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyIngressRule { return vs[0].([]NetworkPolicyIngressRule)[vs[1].(int)] @@ -5405,6 +6270,12 @@ func (i NetworkPolicyIngressRulePatchArgs) ToNetworkPolicyIngressRulePatchOutput return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRulePatchOutput) } +func (i NetworkPolicyIngressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRulePatch] { + return pulumix.Output[NetworkPolicyIngressRulePatch]{ + OutputState: i.ToNetworkPolicyIngressRulePatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyIngressRulePatchArrayInput is an input type that accepts NetworkPolicyIngressRulePatchArray and NetworkPolicyIngressRulePatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyIngressRulePatchArrayInput` via: // @@ -5430,6 +6301,12 @@ func (i NetworkPolicyIngressRulePatchArray) ToNetworkPolicyIngressRulePatchArray return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyIngressRulePatchArrayOutput) } +func (i NetworkPolicyIngressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRulePatch] { + return pulumix.Output[[]NetworkPolicyIngressRulePatch]{ + OutputState: i.ToNetworkPolicyIngressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from. type NetworkPolicyIngressRulePatchOutput struct{ *pulumi.OutputState } @@ -5445,6 +6322,12 @@ func (o NetworkPolicyIngressRulePatchOutput) ToNetworkPolicyIngressRulePatchOutp return o } +func (o NetworkPolicyIngressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyIngressRulePatch] { + return pulumix.Output[NetworkPolicyIngressRulePatch]{ + OutputState: o.OutputState, + } +} + // from is a list of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. func (o NetworkPolicyIngressRulePatchOutput) From() NetworkPolicyPeerPatchArrayOutput { return o.ApplyT(func(v NetworkPolicyIngressRulePatch) []NetworkPolicyPeerPatch { return v.From }).(NetworkPolicyPeerPatchArrayOutput) @@ -5469,6 +6352,12 @@ func (o NetworkPolicyIngressRulePatchArrayOutput) ToNetworkPolicyIngressRulePatc return o } +func (o NetworkPolicyIngressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyIngressRulePatch] { + return pulumix.Output[[]NetworkPolicyIngressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyIngressRulePatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyIngressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyIngressRulePatch { return vs[0].([]NetworkPolicyIngressRulePatch)[vs[1].(int)] @@ -5522,6 +6411,12 @@ func (i NetworkPolicyListTypeArgs) ToNetworkPolicyListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyListTypeOutput) } +func (i NetworkPolicyListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyListType] { + return pulumix.Output[NetworkPolicyListType]{ + OutputState: i.ToNetworkPolicyListTypeOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyList is a list of NetworkPolicy objects. type NetworkPolicyListTypeOutput struct{ *pulumi.OutputState } @@ -5537,6 +6432,12 @@ func (o NetworkPolicyListTypeOutput) ToNetworkPolicyListTypeOutputWithContext(ct return o } +func (o NetworkPolicyListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyListType] { + return pulumix.Output[NetworkPolicyListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NetworkPolicyListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5608,6 +6509,12 @@ func (i NetworkPolicyPatchTypeArgs) ToNetworkPolicyPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPatchTypeOutput) } +func (i NetworkPolicyPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPatchType] { + return pulumix.Output[NetworkPolicyPatchType]{ + OutputState: i.ToNetworkPolicyPatchTypeOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicy describes what network traffic is allowed for a set of Pods type NetworkPolicyPatchTypeOutput struct{ *pulumi.OutputState } @@ -5623,6 +6530,12 @@ func (o NetworkPolicyPatchTypeOutput) ToNetworkPolicyPatchTypeOutputWithContext( return o } +func (o NetworkPolicyPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPatchType] { + return pulumix.Output[NetworkPolicyPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o NetworkPolicyPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v NetworkPolicyPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -5699,6 +6612,12 @@ func (i NetworkPolicyPeerArgs) ToNetworkPolicyPeerOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerOutput) } +func (i NetworkPolicyPeerArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeer] { + return pulumix.Output[NetworkPolicyPeer]{ + OutputState: i.ToNetworkPolicyPeerOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPeerArrayInput is an input type that accepts NetworkPolicyPeerArray and NetworkPolicyPeerArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPeerArrayInput` via: // @@ -5724,6 +6643,12 @@ func (i NetworkPolicyPeerArray) ToNetworkPolicyPeerArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerArrayOutput) } +func (i NetworkPolicyPeerArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeer] { + return pulumix.Output[[]NetworkPolicyPeer]{ + OutputState: i.ToNetworkPolicyPeerArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPeer describes a peer to allow traffic to/from. Only certain combinations of fields are allowed type NetworkPolicyPeerOutput struct{ *pulumi.OutputState } @@ -5739,6 +6664,12 @@ func (o NetworkPolicyPeerOutput) ToNetworkPolicyPeerOutputWithContext(ctx contex return o } +func (o NetworkPolicyPeerOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeer] { + return pulumix.Output[NetworkPolicyPeer]{ + OutputState: o.OutputState, + } +} + // ipBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be. func (o NetworkPolicyPeerOutput) IpBlock() IPBlockPtrOutput { return o.ApplyT(func(v NetworkPolicyPeer) *IPBlock { return v.IpBlock }).(IPBlockPtrOutput) @@ -5772,6 +6703,12 @@ func (o NetworkPolicyPeerArrayOutput) ToNetworkPolicyPeerArrayOutputWithContext( return o } +func (o NetworkPolicyPeerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeer] { + return pulumix.Output[[]NetworkPolicyPeer]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPeerArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPeerOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPeer { return vs[0].([]NetworkPolicyPeer)[vs[1].(int)] @@ -5829,6 +6766,12 @@ func (i NetworkPolicyPeerPatchArgs) ToNetworkPolicyPeerPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerPatchOutput) } +func (i NetworkPolicyPeerPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeerPatch] { + return pulumix.Output[NetworkPolicyPeerPatch]{ + OutputState: i.ToNetworkPolicyPeerPatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPeerPatchArrayInput is an input type that accepts NetworkPolicyPeerPatchArray and NetworkPolicyPeerPatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPeerPatchArrayInput` via: // @@ -5854,6 +6797,12 @@ func (i NetworkPolicyPeerPatchArray) ToNetworkPolicyPeerPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPeerPatchArrayOutput) } +func (i NetworkPolicyPeerPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeerPatch] { + return pulumix.Output[[]NetworkPolicyPeerPatch]{ + OutputState: i.ToNetworkPolicyPeerPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPeer describes a peer to allow traffic to/from. Only certain combinations of fields are allowed type NetworkPolicyPeerPatchOutput struct{ *pulumi.OutputState } @@ -5869,6 +6818,12 @@ func (o NetworkPolicyPeerPatchOutput) ToNetworkPolicyPeerPatchOutputWithContext( return o } +func (o NetworkPolicyPeerPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPeerPatch] { + return pulumix.Output[NetworkPolicyPeerPatch]{ + OutputState: o.OutputState, + } +} + // ipBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be. func (o NetworkPolicyPeerPatchOutput) IpBlock() IPBlockPatchPtrOutput { return o.ApplyT(func(v NetworkPolicyPeerPatch) *IPBlockPatch { return v.IpBlock }).(IPBlockPatchPtrOutput) @@ -5902,6 +6857,12 @@ func (o NetworkPolicyPeerPatchArrayOutput) ToNetworkPolicyPeerPatchArrayOutputWi return o } +func (o NetworkPolicyPeerPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPeerPatch] { + return pulumix.Output[[]NetworkPolicyPeerPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPeerPatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPeerPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPeerPatch { return vs[0].([]NetworkPolicyPeerPatch)[vs[1].(int)] @@ -5951,6 +6912,12 @@ func (i NetworkPolicyPortArgs) ToNetworkPolicyPortOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortOutput) } +func (i NetworkPolicyPortArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPort] { + return pulumix.Output[NetworkPolicyPort]{ + OutputState: i.ToNetworkPolicyPortOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPortArrayInput is an input type that accepts NetworkPolicyPortArray and NetworkPolicyPortArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPortArrayInput` via: // @@ -5976,6 +6943,12 @@ func (i NetworkPolicyPortArray) ToNetworkPolicyPortArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortArrayOutput) } +func (i NetworkPolicyPortArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPort] { + return pulumix.Output[[]NetworkPolicyPort]{ + OutputState: i.ToNetworkPolicyPortArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPort describes a port to allow traffic on type NetworkPolicyPortOutput struct{ *pulumi.OutputState } @@ -5991,6 +6964,12 @@ func (o NetworkPolicyPortOutput) ToNetworkPolicyPortOutputWithContext(ctx contex return o } +func (o NetworkPolicyPortOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPort] { + return pulumix.Output[NetworkPolicyPort]{ + OutputState: o.OutputState, + } +} + // endPort indicates that the range of ports from port to endPort if set, inclusive, should be allowed by the policy. This field cannot be defined if the port field is not defined or if the port field is defined as a named (string) port. The endPort must be equal or greater than port. func (o NetworkPolicyPortOutput) EndPort() pulumi.IntPtrOutput { return o.ApplyT(func(v NetworkPolicyPort) *int { return v.EndPort }).(pulumi.IntPtrOutput) @@ -6020,6 +6999,12 @@ func (o NetworkPolicyPortArrayOutput) ToNetworkPolicyPortArrayOutputWithContext( return o } +func (o NetworkPolicyPortArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPort] { + return pulumix.Output[[]NetworkPolicyPort]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPortArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPortOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPort { return vs[0].([]NetworkPolicyPort)[vs[1].(int)] @@ -6069,6 +7054,12 @@ func (i NetworkPolicyPortPatchArgs) ToNetworkPolicyPortPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortPatchOutput) } +func (i NetworkPolicyPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPortPatch] { + return pulumix.Output[NetworkPolicyPortPatch]{ + OutputState: i.ToNetworkPolicyPortPatchOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPortPatchArrayInput is an input type that accepts NetworkPolicyPortPatchArray and NetworkPolicyPortPatchArrayOutput values. // You can construct a concrete instance of `NetworkPolicyPortPatchArrayInput` via: // @@ -6094,6 +7085,12 @@ func (i NetworkPolicyPortPatchArray) ToNetworkPolicyPortPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyPortPatchArrayOutput) } +func (i NetworkPolicyPortPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPortPatch] { + return pulumix.Output[[]NetworkPolicyPortPatch]{ + OutputState: i.ToNetworkPolicyPortPatchArrayOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyPort describes a port to allow traffic on type NetworkPolicyPortPatchOutput struct{ *pulumi.OutputState } @@ -6109,6 +7106,12 @@ func (o NetworkPolicyPortPatchOutput) ToNetworkPolicyPortPatchOutputWithContext( return o } +func (o NetworkPolicyPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyPortPatch] { + return pulumix.Output[NetworkPolicyPortPatch]{ + OutputState: o.OutputState, + } +} + // endPort indicates that the range of ports from port to endPort if set, inclusive, should be allowed by the policy. This field cannot be defined if the port field is not defined or if the port field is defined as a named (string) port. The endPort must be equal or greater than port. func (o NetworkPolicyPortPatchOutput) EndPort() pulumi.IntPtrOutput { return o.ApplyT(func(v NetworkPolicyPortPatch) *int { return v.EndPort }).(pulumi.IntPtrOutput) @@ -6138,6 +7141,12 @@ func (o NetworkPolicyPortPatchArrayOutput) ToNetworkPolicyPortPatchArrayOutputWi return o } +func (o NetworkPolicyPortPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]NetworkPolicyPortPatch] { + return pulumix.Output[[]NetworkPolicyPortPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyPortPatchArrayOutput) Index(i pulumi.IntInput) NetworkPolicyPortPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkPolicyPortPatch { return vs[0].([]NetworkPolicyPortPatch)[vs[1].(int)] @@ -6191,6 +7200,12 @@ func (i NetworkPolicySpecArgs) ToNetworkPolicySpecOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecOutput) } +func (i NetworkPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpec] { + return pulumix.Output[NetworkPolicySpec]{ + OutputState: i.ToNetworkPolicySpecOutputWithContext(ctx).OutputState, + } +} + func (i NetworkPolicySpecArgs) ToNetworkPolicySpecPtrOutput() NetworkPolicySpecPtrOutput { return i.ToNetworkPolicySpecPtrOutputWithContext(context.Background()) } @@ -6232,6 +7247,12 @@ func (i *networkPolicySpecPtrType) ToNetworkPolicySpecPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecPtrOutput) } +func (i *networkPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpec] { + return pulumix.Output[*NetworkPolicySpec]{ + OutputState: i.ToNetworkPolicySpecPtrOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicySpec provides the specification of a NetworkPolicy type NetworkPolicySpecOutput struct{ *pulumi.OutputState } @@ -6257,6 +7278,12 @@ func (o NetworkPolicySpecOutput) ToNetworkPolicySpecPtrOutputWithContext(ctx con }).(NetworkPolicySpecPtrOutput) } +func (o NetworkPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpec] { + return pulumix.Output[NetworkPolicySpec]{ + OutputState: o.OutputState, + } +} + // egress is a list of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 func (o NetworkPolicySpecOutput) Egress() NetworkPolicyEgressRuleArrayOutput { return o.ApplyT(func(v NetworkPolicySpec) []NetworkPolicyEgressRule { return v.Egress }).(NetworkPolicyEgressRuleArrayOutput) @@ -6291,6 +7318,12 @@ func (o NetworkPolicySpecPtrOutput) ToNetworkPolicySpecPtrOutputWithContext(ctx return o } +func (o NetworkPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpec] { + return pulumix.Output[*NetworkPolicySpec]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicySpecPtrOutput) Elem() NetworkPolicySpecOutput { return o.ApplyT(func(v *NetworkPolicySpec) NetworkPolicySpec { if v != nil { @@ -6388,6 +7421,12 @@ func (i NetworkPolicySpecPatchArgs) ToNetworkPolicySpecPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecPatchOutput) } +func (i NetworkPolicySpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpecPatch] { + return pulumix.Output[NetworkPolicySpecPatch]{ + OutputState: i.ToNetworkPolicySpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i NetworkPolicySpecPatchArgs) ToNetworkPolicySpecPatchPtrOutput() NetworkPolicySpecPatchPtrOutput { return i.ToNetworkPolicySpecPatchPtrOutputWithContext(context.Background()) } @@ -6429,6 +7468,12 @@ func (i *networkPolicySpecPatchPtrType) ToNetworkPolicySpecPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicySpecPatchPtrOutput) } +func (i *networkPolicySpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpecPatch] { + return pulumix.Output[*NetworkPolicySpecPatch]{ + OutputState: i.ToNetworkPolicySpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicySpec provides the specification of a NetworkPolicy type NetworkPolicySpecPatchOutput struct{ *pulumi.OutputState } @@ -6454,6 +7499,12 @@ func (o NetworkPolicySpecPatchOutput) ToNetworkPolicySpecPatchPtrOutputWithConte }).(NetworkPolicySpecPatchPtrOutput) } +func (o NetworkPolicySpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicySpecPatch] { + return pulumix.Output[NetworkPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + // egress is a list of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 func (o NetworkPolicySpecPatchOutput) Egress() NetworkPolicyEgressRulePatchArrayOutput { return o.ApplyT(func(v NetworkPolicySpecPatch) []NetworkPolicyEgressRulePatch { return v.Egress }).(NetworkPolicyEgressRulePatchArrayOutput) @@ -6488,6 +7539,12 @@ func (o NetworkPolicySpecPatchPtrOutput) ToNetworkPolicySpecPatchPtrOutputWithCo return o } +func (o NetworkPolicySpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicySpecPatch] { + return pulumix.Output[*NetworkPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicySpecPatchPtrOutput) Elem() NetworkPolicySpecPatchOutput { return o.ApplyT(func(v *NetworkPolicySpecPatch) NetworkPolicySpecPatch { if v != nil { @@ -6573,6 +7630,12 @@ func (i NetworkPolicyStatusArgs) ToNetworkPolicyStatusOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyStatusOutput) } +func (i NetworkPolicyStatusArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyStatus] { + return pulumix.Output[NetworkPolicyStatus]{ + OutputState: i.ToNetworkPolicyStatusOutputWithContext(ctx).OutputState, + } +} + func (i NetworkPolicyStatusArgs) ToNetworkPolicyStatusPtrOutput() NetworkPolicyStatusPtrOutput { return i.ToNetworkPolicyStatusPtrOutputWithContext(context.Background()) } @@ -6614,6 +7677,12 @@ func (i *networkPolicyStatusPtrType) ToNetworkPolicyStatusPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyStatusPtrOutput) } +func (i *networkPolicyStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyStatus] { + return pulumix.Output[*NetworkPolicyStatus]{ + OutputState: i.ToNetworkPolicyStatusPtrOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyStatus describe the current state of the NetworkPolicy. type NetworkPolicyStatusOutput struct{ *pulumi.OutputState } @@ -6639,6 +7708,12 @@ func (o NetworkPolicyStatusOutput) ToNetworkPolicyStatusPtrOutputWithContext(ctx }).(NetworkPolicyStatusPtrOutput) } +func (o NetworkPolicyStatusOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyStatus] { + return pulumix.Output[NetworkPolicyStatus]{ + OutputState: o.OutputState, + } +} + // Conditions holds an array of metav1.Condition that describe the state of the NetworkPolicy. Current service state func (o NetworkPolicyStatusOutput) Conditions() metav1.ConditionArrayOutput { return o.ApplyT(func(v NetworkPolicyStatus) []metav1.Condition { return v.Conditions }).(metav1.ConditionArrayOutput) @@ -6658,6 +7733,12 @@ func (o NetworkPolicyStatusPtrOutput) ToNetworkPolicyStatusPtrOutputWithContext( return o } +func (o NetworkPolicyStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyStatus] { + return pulumix.Output[*NetworkPolicyStatus]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyStatusPtrOutput) Elem() NetworkPolicyStatusOutput { return o.ApplyT(func(v *NetworkPolicyStatus) NetworkPolicyStatus { if v != nil { @@ -6713,6 +7794,12 @@ func (i NetworkPolicyStatusPatchArgs) ToNetworkPolicyStatusPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyStatusPatchOutput) } +func (i NetworkPolicyStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyStatusPatch] { + return pulumix.Output[NetworkPolicyStatusPatch]{ + OutputState: i.ToNetworkPolicyStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i NetworkPolicyStatusPatchArgs) ToNetworkPolicyStatusPatchPtrOutput() NetworkPolicyStatusPatchPtrOutput { return i.ToNetworkPolicyStatusPatchPtrOutputWithContext(context.Background()) } @@ -6754,6 +7841,12 @@ func (i *networkPolicyStatusPatchPtrType) ToNetworkPolicyStatusPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(NetworkPolicyStatusPatchPtrOutput) } +func (i *networkPolicyStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyStatusPatch] { + return pulumix.Output[*NetworkPolicyStatusPatch]{ + OutputState: i.ToNetworkPolicyStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // NetworkPolicyStatus describe the current state of the NetworkPolicy. type NetworkPolicyStatusPatchOutput struct{ *pulumi.OutputState } @@ -6779,6 +7872,12 @@ func (o NetworkPolicyStatusPatchOutput) ToNetworkPolicyStatusPatchPtrOutputWithC }).(NetworkPolicyStatusPatchPtrOutput) } +func (o NetworkPolicyStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[NetworkPolicyStatusPatch] { + return pulumix.Output[NetworkPolicyStatusPatch]{ + OutputState: o.OutputState, + } +} + // Conditions holds an array of metav1.Condition that describe the state of the NetworkPolicy. Current service state func (o NetworkPolicyStatusPatchOutput) Conditions() metav1.ConditionPatchArrayOutput { return o.ApplyT(func(v NetworkPolicyStatusPatch) []metav1.ConditionPatch { return v.Conditions }).(metav1.ConditionPatchArrayOutput) @@ -6798,6 +7897,12 @@ func (o NetworkPolicyStatusPatchPtrOutput) ToNetworkPolicyStatusPatchPtrOutputWi return o } +func (o NetworkPolicyStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*NetworkPolicyStatusPatch] { + return pulumix.Output[*NetworkPolicyStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o NetworkPolicyStatusPatchPtrOutput) Elem() NetworkPolicyStatusPatchOutput { return o.ApplyT(func(v *NetworkPolicyStatusPatch) NetworkPolicyStatusPatch { if v != nil { @@ -6857,6 +7962,12 @@ func (i ServiceBackendPortArgs) ToServiceBackendPortOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ServiceBackendPortOutput) } +func (i ServiceBackendPortArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceBackendPort] { + return pulumix.Output[ServiceBackendPort]{ + OutputState: i.ToServiceBackendPortOutputWithContext(ctx).OutputState, + } +} + func (i ServiceBackendPortArgs) ToServiceBackendPortPtrOutput() ServiceBackendPortPtrOutput { return i.ToServiceBackendPortPtrOutputWithContext(context.Background()) } @@ -6898,6 +8009,12 @@ func (i *serviceBackendPortPtrType) ToServiceBackendPortPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ServiceBackendPortPtrOutput) } +func (i *serviceBackendPortPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceBackendPort] { + return pulumix.Output[*ServiceBackendPort]{ + OutputState: i.ToServiceBackendPortPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceBackendPort is the service port being referenced. type ServiceBackendPortOutput struct{ *pulumi.OutputState } @@ -6923,6 +8040,12 @@ func (o ServiceBackendPortOutput) ToServiceBackendPortPtrOutputWithContext(ctx c }).(ServiceBackendPortPtrOutput) } +func (o ServiceBackendPortOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceBackendPort] { + return pulumix.Output[ServiceBackendPort]{ + OutputState: o.OutputState, + } +} + // name is the name of the port on the Service. This is a mutually exclusive setting with "Number". func (o ServiceBackendPortOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceBackendPort) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -6947,6 +8070,12 @@ func (o ServiceBackendPortPtrOutput) ToServiceBackendPortPtrOutputWithContext(ct return o } +func (o ServiceBackendPortPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceBackendPort] { + return pulumix.Output[*ServiceBackendPort]{ + OutputState: o.OutputState, + } +} + func (o ServiceBackendPortPtrOutput) Elem() ServiceBackendPortOutput { return o.ApplyT(func(v *ServiceBackendPort) ServiceBackendPort { if v != nil { @@ -7016,6 +8145,12 @@ func (i ServiceBackendPortPatchArgs) ToServiceBackendPortPatchOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ServiceBackendPortPatchOutput) } +func (i ServiceBackendPortPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ServiceBackendPortPatch] { + return pulumix.Output[ServiceBackendPortPatch]{ + OutputState: i.ToServiceBackendPortPatchOutputWithContext(ctx).OutputState, + } +} + func (i ServiceBackendPortPatchArgs) ToServiceBackendPortPatchPtrOutput() ServiceBackendPortPatchPtrOutput { return i.ToServiceBackendPortPatchPtrOutputWithContext(context.Background()) } @@ -7057,6 +8192,12 @@ func (i *serviceBackendPortPatchPtrType) ToServiceBackendPortPatchPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(ServiceBackendPortPatchPtrOutput) } +func (i *serviceBackendPortPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ServiceBackendPortPatch] { + return pulumix.Output[*ServiceBackendPortPatch]{ + OutputState: i.ToServiceBackendPortPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ServiceBackendPort is the service port being referenced. type ServiceBackendPortPatchOutput struct{ *pulumi.OutputState } @@ -7082,6 +8223,12 @@ func (o ServiceBackendPortPatchOutput) ToServiceBackendPortPatchPtrOutputWithCon }).(ServiceBackendPortPatchPtrOutput) } +func (o ServiceBackendPortPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ServiceBackendPortPatch] { + return pulumix.Output[ServiceBackendPortPatch]{ + OutputState: o.OutputState, + } +} + // name is the name of the port on the Service. This is a mutually exclusive setting with "Number". func (o ServiceBackendPortPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ServiceBackendPortPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -7106,6 +8253,12 @@ func (o ServiceBackendPortPatchPtrOutput) ToServiceBackendPortPatchPtrOutputWith return o } +func (o ServiceBackendPortPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ServiceBackendPortPatch] { + return pulumix.Output[*ServiceBackendPortPatch]{ + OutputState: o.OutputState, + } +} + func (o ServiceBackendPortPatchPtrOutput) Elem() ServiceBackendPortPatchOutput { return o.ApplyT(func(v *ServiceBackendPortPatch) ServiceBackendPortPatch { if v != nil { diff --git a/sdk/go/kubernetes/networking/v1alpha1/clusterCIDR.go b/sdk/go/kubernetes/networking/v1alpha1/clusterCIDR.go index 5edc4a0254..6ab7a7d84a 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/clusterCIDR.go +++ b/sdk/go/kubernetes/networking/v1alpha1/clusterCIDR.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterCIDR represents a single configuration for per-Node Pod CIDR allocations when the MultiCIDRRangeAllocator is enabled (see the config for kube-controller-manager). A cluster may have any number of ClusterCIDR resources, all of which will be considered when allocating a CIDR for a Node. A ClusterCIDR is eligible to be used for a given Node when the node selector matches the node in question and has free CIDRs to allocate. In case of multiple matching ClusterCIDR resources, the allocator will attempt to break ties using internal heuristics, but any ClusterCIDR whose node selector matches the Node may be used. @@ -113,6 +114,12 @@ func (i *ClusterCIDR) ToClusterCIDROutputWithContext(ctx context.Context) Cluste return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDROutput) } +func (i *ClusterCIDR) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDR] { + return pulumix.Output[*ClusterCIDR]{ + OutputState: i.ToClusterCIDROutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRArrayInput is an input type that accepts ClusterCIDRArray and ClusterCIDRArrayOutput values. // You can construct a concrete instance of `ClusterCIDRArrayInput` via: // @@ -138,6 +145,12 @@ func (i ClusterCIDRArray) ToClusterCIDRArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRArrayOutput) } +func (i ClusterCIDRArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterCIDR] { + return pulumix.Output[[]*ClusterCIDR]{ + OutputState: i.ToClusterCIDRArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRMapInput is an input type that accepts ClusterCIDRMap and ClusterCIDRMapOutput values. // You can construct a concrete instance of `ClusterCIDRMapInput` via: // @@ -163,6 +176,12 @@ func (i ClusterCIDRMap) ToClusterCIDRMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRMapOutput) } +func (i ClusterCIDRMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterCIDR] { + return pulumix.Output[map[string]*ClusterCIDR]{ + OutputState: i.ToClusterCIDRMapOutputWithContext(ctx).OutputState, + } +} + type ClusterCIDROutput struct{ *pulumi.OutputState } func (ClusterCIDROutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o ClusterCIDROutput) ToClusterCIDROutputWithContext(ctx context.Context) C return o } +func (o ClusterCIDROutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDR] { + return pulumix.Output[*ClusterCIDR]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterCIDROutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterCIDR) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o ClusterCIDRArrayOutput) ToClusterCIDRArrayOutputWithContext(ctx context. return o } +func (o ClusterCIDRArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterCIDR] { + return pulumix.Output[[]*ClusterCIDR]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRArrayOutput) Index(i pulumi.IntInput) ClusterCIDROutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterCIDR { return vs[0].([]*ClusterCIDR)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o ClusterCIDRMapOutput) ToClusterCIDRMapOutputWithContext(ctx context.Cont return o } +func (o ClusterCIDRMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterCIDR] { + return pulumix.Output[map[string]*ClusterCIDR]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRMapOutput) MapIndex(k pulumi.StringInput) ClusterCIDROutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterCIDR { return vs[0].(map[string]*ClusterCIDR)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRList.go b/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRList.go index 51fec0fe8d..873a22d93a 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRList.go +++ b/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterCIDRList contains a list of ClusterCIDR. @@ -117,6 +118,12 @@ func (i *ClusterCIDRList) ToClusterCIDRListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRListOutput) } +func (i *ClusterCIDRList) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRList] { + return pulumix.Output[*ClusterCIDRList]{ + OutputState: i.ToClusterCIDRListOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRListArrayInput is an input type that accepts ClusterCIDRListArray and ClusterCIDRListArrayOutput values. // You can construct a concrete instance of `ClusterCIDRListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterCIDRListArray) ToClusterCIDRListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRListArrayOutput) } +func (i ClusterCIDRListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterCIDRList] { + return pulumix.Output[[]*ClusterCIDRList]{ + OutputState: i.ToClusterCIDRListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRListMapInput is an input type that accepts ClusterCIDRListMap and ClusterCIDRListMapOutput values. // You can construct a concrete instance of `ClusterCIDRListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterCIDRListMap) ToClusterCIDRListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRListMapOutput) } +func (i ClusterCIDRListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterCIDRList] { + return pulumix.Output[map[string]*ClusterCIDRList]{ + OutputState: i.ToClusterCIDRListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterCIDRListOutput struct{ *pulumi.OutputState } func (ClusterCIDRListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterCIDRListOutput) ToClusterCIDRListOutputWithContext(ctx context.Co return o } +func (o ClusterCIDRListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRList] { + return pulumix.Output[*ClusterCIDRList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterCIDRListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterCIDRList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterCIDRListArrayOutput) ToClusterCIDRListArrayOutputWithContext(ctx return o } +func (o ClusterCIDRListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterCIDRList] { + return pulumix.Output[[]*ClusterCIDRList]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRListArrayOutput) Index(i pulumi.IntInput) ClusterCIDRListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterCIDRList { return vs[0].([]*ClusterCIDRList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterCIDRListMapOutput) ToClusterCIDRListMapOutputWithContext(ctx cont return o } +func (o ClusterCIDRListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterCIDRList] { + return pulumix.Output[map[string]*ClusterCIDRList]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRListMapOutput) MapIndex(k pulumi.StringInput) ClusterCIDRListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterCIDRList { return vs[0].(map[string]*ClusterCIDRList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRPatch.go b/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRPatch.go index df7a24ab8e..5c5a29ab99 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRPatch.go +++ b/sdk/go/kubernetes/networking/v1alpha1/clusterCIDRPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -119,6 +120,12 @@ func (i *ClusterCIDRPatch) ToClusterCIDRPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRPatchOutput) } +func (i *ClusterCIDRPatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRPatch] { + return pulumix.Output[*ClusterCIDRPatch]{ + OutputState: i.ToClusterCIDRPatchOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRPatchArrayInput is an input type that accepts ClusterCIDRPatchArray and ClusterCIDRPatchArrayOutput values. // You can construct a concrete instance of `ClusterCIDRPatchArrayInput` via: // @@ -144,6 +151,12 @@ func (i ClusterCIDRPatchArray) ToClusterCIDRPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRPatchArrayOutput) } +func (i ClusterCIDRPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterCIDRPatch] { + return pulumix.Output[[]*ClusterCIDRPatch]{ + OutputState: i.ToClusterCIDRPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRPatchMapInput is an input type that accepts ClusterCIDRPatchMap and ClusterCIDRPatchMapOutput values. // You can construct a concrete instance of `ClusterCIDRPatchMapInput` via: // @@ -169,6 +182,12 @@ func (i ClusterCIDRPatchMap) ToClusterCIDRPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRPatchMapOutput) } +func (i ClusterCIDRPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterCIDRPatch] { + return pulumix.Output[map[string]*ClusterCIDRPatch]{ + OutputState: i.ToClusterCIDRPatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterCIDRPatchOutput struct{ *pulumi.OutputState } func (ClusterCIDRPatchOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o ClusterCIDRPatchOutput) ToClusterCIDRPatchOutputWithContext(ctx context. return o } +func (o ClusterCIDRPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRPatch] { + return pulumix.Output[*ClusterCIDRPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterCIDRPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ClusterCIDRPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -217,6 +242,12 @@ func (o ClusterCIDRPatchArrayOutput) ToClusterCIDRPatchArrayOutputWithContext(ct return o } +func (o ClusterCIDRPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterCIDRPatch] { + return pulumix.Output[[]*ClusterCIDRPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRPatchArrayOutput) Index(i pulumi.IntInput) ClusterCIDRPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterCIDRPatch { return vs[0].([]*ClusterCIDRPatch)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o ClusterCIDRPatchMapOutput) ToClusterCIDRPatchMapOutputWithContext(ctx co return o } +func (o ClusterCIDRPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterCIDRPatch] { + return pulumix.Output[map[string]*ClusterCIDRPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRPatchMapOutput) MapIndex(k pulumi.StringInput) ClusterCIDRPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterCIDRPatch { return vs[0].(map[string]*ClusterCIDRPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1alpha1/ipaddress.go b/sdk/go/kubernetes/networking/v1alpha1/ipaddress.go index 56b47451e4..a452cb8773 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/ipaddress.go +++ b/sdk/go/kubernetes/networking/v1alpha1/ipaddress.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1 @@ -113,6 +114,12 @@ func (i *IPAddress) ToIPAddressOutputWithContext(ctx context.Context) IPAddressO return pulumi.ToOutputWithContext(ctx, i).(IPAddressOutput) } +func (i *IPAddress) ToOutput(ctx context.Context) pulumix.Output[*IPAddress] { + return pulumix.Output[*IPAddress]{ + OutputState: i.ToIPAddressOutputWithContext(ctx).OutputState, + } +} + // IPAddressArrayInput is an input type that accepts IPAddressArray and IPAddressArrayOutput values. // You can construct a concrete instance of `IPAddressArrayInput` via: // @@ -138,6 +145,12 @@ func (i IPAddressArray) ToIPAddressArrayOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IPAddressArrayOutput) } +func (i IPAddressArray) ToOutput(ctx context.Context) pulumix.Output[[]*IPAddress] { + return pulumix.Output[[]*IPAddress]{ + OutputState: i.ToIPAddressArrayOutputWithContext(ctx).OutputState, + } +} + // IPAddressMapInput is an input type that accepts IPAddressMap and IPAddressMapOutput values. // You can construct a concrete instance of `IPAddressMapInput` via: // @@ -163,6 +176,12 @@ func (i IPAddressMap) ToIPAddressMapOutputWithContext(ctx context.Context) IPAdd return pulumi.ToOutputWithContext(ctx, i).(IPAddressMapOutput) } +func (i IPAddressMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IPAddress] { + return pulumix.Output[map[string]*IPAddress]{ + OutputState: i.ToIPAddressMapOutputWithContext(ctx).OutputState, + } +} + type IPAddressOutput struct{ *pulumi.OutputState } func (IPAddressOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o IPAddressOutput) ToIPAddressOutputWithContext(ctx context.Context) IPAdd return o } +func (o IPAddressOutput) ToOutput(ctx context.Context) pulumix.Output[*IPAddress] { + return pulumix.Output[*IPAddress]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IPAddressOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IPAddress) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -211,6 +236,12 @@ func (o IPAddressArrayOutput) ToIPAddressArrayOutputWithContext(ctx context.Cont return o } +func (o IPAddressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IPAddress] { + return pulumix.Output[[]*IPAddress]{ + OutputState: o.OutputState, + } +} + func (o IPAddressArrayOutput) Index(i pulumi.IntInput) IPAddressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IPAddress { return vs[0].([]*IPAddress)[vs[1].(int)] @@ -231,6 +262,12 @@ func (o IPAddressMapOutput) ToIPAddressMapOutputWithContext(ctx context.Context) return o } +func (o IPAddressMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IPAddress] { + return pulumix.Output[map[string]*IPAddress]{ + OutputState: o.OutputState, + } +} + func (o IPAddressMapOutput) MapIndex(k pulumi.StringInput) IPAddressOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IPAddress { return vs[0].(map[string]*IPAddress)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1alpha1/ipaddressList.go b/sdk/go/kubernetes/networking/v1alpha1/ipaddressList.go index 33554f9e06..23596ece85 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/ipaddressList.go +++ b/sdk/go/kubernetes/networking/v1alpha1/ipaddressList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IPAddressList contains a list of IPAddress. @@ -117,6 +118,12 @@ func (i *IPAddressList) ToIPAddressListOutputWithContext(ctx context.Context) IP return pulumi.ToOutputWithContext(ctx, i).(IPAddressListOutput) } +func (i *IPAddressList) ToOutput(ctx context.Context) pulumix.Output[*IPAddressList] { + return pulumix.Output[*IPAddressList]{ + OutputState: i.ToIPAddressListOutputWithContext(ctx).OutputState, + } +} + // IPAddressListArrayInput is an input type that accepts IPAddressListArray and IPAddressListArrayOutput values. // You can construct a concrete instance of `IPAddressListArrayInput` via: // @@ -142,6 +149,12 @@ func (i IPAddressListArray) ToIPAddressListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IPAddressListArrayOutput) } +func (i IPAddressListArray) ToOutput(ctx context.Context) pulumix.Output[[]*IPAddressList] { + return pulumix.Output[[]*IPAddressList]{ + OutputState: i.ToIPAddressListArrayOutputWithContext(ctx).OutputState, + } +} + // IPAddressListMapInput is an input type that accepts IPAddressListMap and IPAddressListMapOutput values. // You can construct a concrete instance of `IPAddressListMapInput` via: // @@ -167,6 +180,12 @@ func (i IPAddressListMap) ToIPAddressListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IPAddressListMapOutput) } +func (i IPAddressListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IPAddressList] { + return pulumix.Output[map[string]*IPAddressList]{ + OutputState: i.ToIPAddressListMapOutputWithContext(ctx).OutputState, + } +} + type IPAddressListOutput struct{ *pulumi.OutputState } func (IPAddressListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o IPAddressListOutput) ToIPAddressListOutputWithContext(ctx context.Contex return o } +func (o IPAddressListOutput) ToOutput(ctx context.Context) pulumix.Output[*IPAddressList] { + return pulumix.Output[*IPAddressList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IPAddressListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IPAddressList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o IPAddressListArrayOutput) ToIPAddressListArrayOutputWithContext(ctx cont return o } +func (o IPAddressListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IPAddressList] { + return pulumix.Output[[]*IPAddressList]{ + OutputState: o.OutputState, + } +} + func (o IPAddressListArrayOutput) Index(i pulumi.IntInput) IPAddressListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IPAddressList { return vs[0].([]*IPAddressList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o IPAddressListMapOutput) ToIPAddressListMapOutputWithContext(ctx context. return o } +func (o IPAddressListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IPAddressList] { + return pulumix.Output[map[string]*IPAddressList]{ + OutputState: o.OutputState, + } +} + func (o IPAddressListMapOutput) MapIndex(k pulumi.StringInput) IPAddressListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IPAddressList { return vs[0].(map[string]*IPAddressList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1alpha1/ipaddressPatch.go b/sdk/go/kubernetes/networking/v1alpha1/ipaddressPatch.go index 0d982afcdc..ce9110ee92 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/ipaddressPatch.go +++ b/sdk/go/kubernetes/networking/v1alpha1/ipaddressPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -119,6 +120,12 @@ func (i *IPAddressPatch) ToIPAddressPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IPAddressPatchOutput) } +func (i *IPAddressPatch) ToOutput(ctx context.Context) pulumix.Output[*IPAddressPatch] { + return pulumix.Output[*IPAddressPatch]{ + OutputState: i.ToIPAddressPatchOutputWithContext(ctx).OutputState, + } +} + // IPAddressPatchArrayInput is an input type that accepts IPAddressPatchArray and IPAddressPatchArrayOutput values. // You can construct a concrete instance of `IPAddressPatchArrayInput` via: // @@ -144,6 +151,12 @@ func (i IPAddressPatchArray) ToIPAddressPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(IPAddressPatchArrayOutput) } +func (i IPAddressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*IPAddressPatch] { + return pulumix.Output[[]*IPAddressPatch]{ + OutputState: i.ToIPAddressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IPAddressPatchMapInput is an input type that accepts IPAddressPatchMap and IPAddressPatchMapOutput values. // You can construct a concrete instance of `IPAddressPatchMapInput` via: // @@ -169,6 +182,12 @@ func (i IPAddressPatchMap) ToIPAddressPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IPAddressPatchMapOutput) } +func (i IPAddressPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IPAddressPatch] { + return pulumix.Output[map[string]*IPAddressPatch]{ + OutputState: i.ToIPAddressPatchMapOutputWithContext(ctx).OutputState, + } +} + type IPAddressPatchOutput struct{ *pulumi.OutputState } func (IPAddressPatchOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o IPAddressPatchOutput) ToIPAddressPatchOutputWithContext(ctx context.Cont return o } +func (o IPAddressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*IPAddressPatch] { + return pulumix.Output[*IPAddressPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IPAddressPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *IPAddressPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -217,6 +242,12 @@ func (o IPAddressPatchArrayOutput) ToIPAddressPatchArrayOutputWithContext(ctx co return o } +func (o IPAddressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IPAddressPatch] { + return pulumix.Output[[]*IPAddressPatch]{ + OutputState: o.OutputState, + } +} + func (o IPAddressPatchArrayOutput) Index(i pulumi.IntInput) IPAddressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IPAddressPatch { return vs[0].([]*IPAddressPatch)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o IPAddressPatchMapOutput) ToIPAddressPatchMapOutputWithContext(ctx contex return o } +func (o IPAddressPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IPAddressPatch] { + return pulumix.Output[map[string]*IPAddressPatch]{ + OutputState: o.OutputState, + } +} + func (o IPAddressPatchMapOutput) MapIndex(k pulumi.StringInput) IPAddressPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IPAddressPatch { return vs[0].(map[string]*IPAddressPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/networking/v1alpha1/pulumiTypes.go index 3de74325c9..4e9c7b7fc2 100644 --- a/sdk/go/kubernetes/networking/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/networking/v1alpha1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -62,6 +63,12 @@ func (i ClusterCIDRTypeArgs) ToClusterCIDRTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRTypeOutput) } +func (i ClusterCIDRTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRType] { + return pulumix.Output[ClusterCIDRType]{ + OutputState: i.ToClusterCIDRTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRTypeArrayInput is an input type that accepts ClusterCIDRTypeArray and ClusterCIDRTypeArrayOutput values. // You can construct a concrete instance of `ClusterCIDRTypeArrayInput` via: // @@ -87,6 +94,12 @@ func (i ClusterCIDRTypeArray) ToClusterCIDRTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRTypeArrayOutput) } +func (i ClusterCIDRTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterCIDRType] { + return pulumix.Output[[]ClusterCIDRType]{ + OutputState: i.ToClusterCIDRTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDR represents a single configuration for per-Node Pod CIDR allocations when the MultiCIDRRangeAllocator is enabled (see the config for kube-controller-manager). A cluster may have any number of ClusterCIDR resources, all of which will be considered when allocating a CIDR for a Node. A ClusterCIDR is eligible to be used for a given Node when the node selector matches the node in question and has free CIDRs to allocate. In case of multiple matching ClusterCIDR resources, the allocator will attempt to break ties using internal heuristics, but any ClusterCIDR whose node selector matches the Node may be used. type ClusterCIDRTypeOutput struct{ *pulumi.OutputState } @@ -102,6 +115,12 @@ func (o ClusterCIDRTypeOutput) ToClusterCIDRTypeOutputWithContext(ctx context.Co return o } +func (o ClusterCIDRTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRType] { + return pulumix.Output[ClusterCIDRType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterCIDRTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterCIDRType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -136,6 +155,12 @@ func (o ClusterCIDRTypeArrayOutput) ToClusterCIDRTypeArrayOutputWithContext(ctx return o } +func (o ClusterCIDRTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterCIDRType] { + return pulumix.Output[[]ClusterCIDRType]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRTypeArrayOutput) Index(i pulumi.IntInput) ClusterCIDRTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterCIDRType { return vs[0].([]ClusterCIDRType)[vs[1].(int)] @@ -189,6 +214,12 @@ func (i ClusterCIDRListTypeArgs) ToClusterCIDRListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRListTypeOutput) } +func (i ClusterCIDRListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRListType] { + return pulumix.Output[ClusterCIDRListType]{ + OutputState: i.ToClusterCIDRListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRList contains a list of ClusterCIDR. type ClusterCIDRListTypeOutput struct{ *pulumi.OutputState } @@ -204,6 +235,12 @@ func (o ClusterCIDRListTypeOutput) ToClusterCIDRListTypeOutputWithContext(ctx co return o } +func (o ClusterCIDRListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRListType] { + return pulumix.Output[ClusterCIDRListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterCIDRListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterCIDRListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -271,6 +308,12 @@ func (i ClusterCIDRPatchTypeArgs) ToClusterCIDRPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRPatchTypeOutput) } +func (i ClusterCIDRPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRPatchType] { + return pulumix.Output[ClusterCIDRPatchType]{ + OutputState: i.ToClusterCIDRPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDR represents a single configuration for per-Node Pod CIDR allocations when the MultiCIDRRangeAllocator is enabled (see the config for kube-controller-manager). A cluster may have any number of ClusterCIDR resources, all of which will be considered when allocating a CIDR for a Node. A ClusterCIDR is eligible to be used for a given Node when the node selector matches the node in question and has free CIDRs to allocate. In case of multiple matching ClusterCIDR resources, the allocator will attempt to break ties using internal heuristics, but any ClusterCIDR whose node selector matches the Node may be used. type ClusterCIDRPatchTypeOutput struct{ *pulumi.OutputState } @@ -286,6 +329,12 @@ func (o ClusterCIDRPatchTypeOutput) ToClusterCIDRPatchTypeOutputWithContext(ctx return o } +func (o ClusterCIDRPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRPatchType] { + return pulumix.Output[ClusterCIDRPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterCIDRPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterCIDRPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -353,6 +402,12 @@ func (i ClusterCIDRSpecArgs) ToClusterCIDRSpecOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRSpecOutput) } +func (i ClusterCIDRSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRSpec] { + return pulumix.Output[ClusterCIDRSpec]{ + OutputState: i.ToClusterCIDRSpecOutputWithContext(ctx).OutputState, + } +} + func (i ClusterCIDRSpecArgs) ToClusterCIDRSpecPtrOutput() ClusterCIDRSpecPtrOutput { return i.ToClusterCIDRSpecPtrOutputWithContext(context.Background()) } @@ -394,6 +449,12 @@ func (i *clusterCIDRSpecPtrType) ToClusterCIDRSpecPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRSpecPtrOutput) } +func (i *clusterCIDRSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRSpec] { + return pulumix.Output[*ClusterCIDRSpec]{ + OutputState: i.ToClusterCIDRSpecPtrOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRSpec defines the desired state of ClusterCIDR. type ClusterCIDRSpecOutput struct{ *pulumi.OutputState } @@ -419,6 +480,12 @@ func (o ClusterCIDRSpecOutput) ToClusterCIDRSpecPtrOutputWithContext(ctx context }).(ClusterCIDRSpecPtrOutput) } +func (o ClusterCIDRSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRSpec] { + return pulumix.Output[ClusterCIDRSpec]{ + OutputState: o.OutputState, + } +} + // ipv4 defines an IPv4 IP block in CIDR notation(e.g. "10.0.0.0/8"). At least one of ipv4 and ipv6 must be specified. This field is immutable. func (o ClusterCIDRSpecOutput) Ipv4() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterCIDRSpec) *string { return v.Ipv4 }).(pulumi.StringPtrOutput) @@ -453,6 +520,12 @@ func (o ClusterCIDRSpecPtrOutput) ToClusterCIDRSpecPtrOutputWithContext(ctx cont return o } +func (o ClusterCIDRSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRSpec] { + return pulumix.Output[*ClusterCIDRSpec]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRSpecPtrOutput) Elem() ClusterCIDRSpecOutput { return o.ApplyT(func(v *ClusterCIDRSpec) ClusterCIDRSpec { if v != nil { @@ -550,6 +623,12 @@ func (i ClusterCIDRSpecPatchArgs) ToClusterCIDRSpecPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRSpecPatchOutput) } +func (i ClusterCIDRSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRSpecPatch] { + return pulumix.Output[ClusterCIDRSpecPatch]{ + OutputState: i.ToClusterCIDRSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ClusterCIDRSpecPatchArgs) ToClusterCIDRSpecPatchPtrOutput() ClusterCIDRSpecPatchPtrOutput { return i.ToClusterCIDRSpecPatchPtrOutputWithContext(context.Background()) } @@ -591,6 +670,12 @@ func (i *clusterCIDRSpecPatchPtrType) ToClusterCIDRSpecPatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ClusterCIDRSpecPatchPtrOutput) } +func (i *clusterCIDRSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRSpecPatch] { + return pulumix.Output[*ClusterCIDRSpecPatch]{ + OutputState: i.ToClusterCIDRSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ClusterCIDRSpec defines the desired state of ClusterCIDR. type ClusterCIDRSpecPatchOutput struct{ *pulumi.OutputState } @@ -616,6 +701,12 @@ func (o ClusterCIDRSpecPatchOutput) ToClusterCIDRSpecPatchPtrOutputWithContext(c }).(ClusterCIDRSpecPatchPtrOutput) } +func (o ClusterCIDRSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterCIDRSpecPatch] { + return pulumix.Output[ClusterCIDRSpecPatch]{ + OutputState: o.OutputState, + } +} + // ipv4 defines an IPv4 IP block in CIDR notation(e.g. "10.0.0.0/8"). At least one of ipv4 and ipv6 must be specified. This field is immutable. func (o ClusterCIDRSpecPatchOutput) Ipv4() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterCIDRSpecPatch) *string { return v.Ipv4 }).(pulumi.StringPtrOutput) @@ -650,6 +741,12 @@ func (o ClusterCIDRSpecPatchPtrOutput) ToClusterCIDRSpecPatchPtrOutputWithContex return o } +func (o ClusterCIDRSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterCIDRSpecPatch] { + return pulumix.Output[*ClusterCIDRSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterCIDRSpecPatchPtrOutput) Elem() ClusterCIDRSpecPatchOutput { return o.ApplyT(func(v *ClusterCIDRSpecPatch) ClusterCIDRSpecPatch { if v != nil { @@ -747,6 +844,12 @@ func (i IPAddressTypeArgs) ToIPAddressTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IPAddressTypeOutput) } +func (i IPAddressTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IPAddressType] { + return pulumix.Output[IPAddressType]{ + OutputState: i.ToIPAddressTypeOutputWithContext(ctx).OutputState, + } +} + // IPAddressTypeArrayInput is an input type that accepts IPAddressTypeArray and IPAddressTypeArrayOutput values. // You can construct a concrete instance of `IPAddressTypeArrayInput` via: // @@ -772,6 +875,12 @@ func (i IPAddressTypeArray) ToIPAddressTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IPAddressTypeArrayOutput) } +func (i IPAddressTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]IPAddressType] { + return pulumix.Output[[]IPAddressType]{ + OutputState: i.ToIPAddressTypeArrayOutputWithContext(ctx).OutputState, + } +} + // IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1 type IPAddressTypeOutput struct{ *pulumi.OutputState } @@ -787,6 +896,12 @@ func (o IPAddressTypeOutput) ToIPAddressTypeOutputWithContext(ctx context.Contex return o } +func (o IPAddressTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IPAddressType] { + return pulumix.Output[IPAddressType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IPAddressTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IPAddressType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -821,6 +936,12 @@ func (o IPAddressTypeArrayOutput) ToIPAddressTypeArrayOutputWithContext(ctx cont return o } +func (o IPAddressTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IPAddressType] { + return pulumix.Output[[]IPAddressType]{ + OutputState: o.OutputState, + } +} + func (o IPAddressTypeArrayOutput) Index(i pulumi.IntInput) IPAddressTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IPAddressType { return vs[0].([]IPAddressType)[vs[1].(int)] @@ -874,6 +995,12 @@ func (i IPAddressListTypeArgs) ToIPAddressListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(IPAddressListTypeOutput) } +func (i IPAddressListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IPAddressListType] { + return pulumix.Output[IPAddressListType]{ + OutputState: i.ToIPAddressListTypeOutputWithContext(ctx).OutputState, + } +} + // IPAddressList contains a list of IPAddress. type IPAddressListTypeOutput struct{ *pulumi.OutputState } @@ -889,6 +1016,12 @@ func (o IPAddressListTypeOutput) ToIPAddressListTypeOutputWithContext(ctx contex return o } +func (o IPAddressListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IPAddressListType] { + return pulumix.Output[IPAddressListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IPAddressListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IPAddressListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -956,6 +1089,12 @@ func (i IPAddressPatchTypeArgs) ToIPAddressPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IPAddressPatchTypeOutput) } +func (i IPAddressPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IPAddressPatchType] { + return pulumix.Output[IPAddressPatchType]{ + OutputState: i.ToIPAddressPatchTypeOutputWithContext(ctx).OutputState, + } +} + // IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1 type IPAddressPatchTypeOutput struct{ *pulumi.OutputState } @@ -971,6 +1110,12 @@ func (o IPAddressPatchTypeOutput) ToIPAddressPatchTypeOutputWithContext(ctx cont return o } +func (o IPAddressPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IPAddressPatchType] { + return pulumix.Output[IPAddressPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IPAddressPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IPAddressPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1026,6 +1171,12 @@ func (i IPAddressSpecArgs) ToIPAddressSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IPAddressSpecOutput) } +func (i IPAddressSpecArgs) ToOutput(ctx context.Context) pulumix.Output[IPAddressSpec] { + return pulumix.Output[IPAddressSpec]{ + OutputState: i.ToIPAddressSpecOutputWithContext(ctx).OutputState, + } +} + func (i IPAddressSpecArgs) ToIPAddressSpecPtrOutput() IPAddressSpecPtrOutput { return i.ToIPAddressSpecPtrOutputWithContext(context.Background()) } @@ -1067,6 +1218,12 @@ func (i *ipaddressSpecPtrType) ToIPAddressSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(IPAddressSpecPtrOutput) } +func (i *ipaddressSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*IPAddressSpec] { + return pulumix.Output[*IPAddressSpec]{ + OutputState: i.ToIPAddressSpecPtrOutputWithContext(ctx).OutputState, + } +} + // IPAddressSpec describe the attributes in an IP Address. type IPAddressSpecOutput struct{ *pulumi.OutputState } @@ -1092,6 +1249,12 @@ func (o IPAddressSpecOutput) ToIPAddressSpecPtrOutputWithContext(ctx context.Con }).(IPAddressSpecPtrOutput) } +func (o IPAddressSpecOutput) ToOutput(ctx context.Context) pulumix.Output[IPAddressSpec] { + return pulumix.Output[IPAddressSpec]{ + OutputState: o.OutputState, + } +} + // ParentRef references the resource that an IPAddress is attached to. An IPAddress must reference a parent object. func (o IPAddressSpecOutput) ParentRef() ParentReferencePtrOutput { return o.ApplyT(func(v IPAddressSpec) *ParentReference { return v.ParentRef }).(ParentReferencePtrOutput) @@ -1111,6 +1274,12 @@ func (o IPAddressSpecPtrOutput) ToIPAddressSpecPtrOutputWithContext(ctx context. return o } +func (o IPAddressSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IPAddressSpec] { + return pulumix.Output[*IPAddressSpec]{ + OutputState: o.OutputState, + } +} + func (o IPAddressSpecPtrOutput) Elem() IPAddressSpecOutput { return o.ApplyT(func(v *IPAddressSpec) IPAddressSpec { if v != nil { @@ -1166,6 +1335,12 @@ func (i IPAddressSpecPatchArgs) ToIPAddressSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IPAddressSpecPatchOutput) } +func (i IPAddressSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IPAddressSpecPatch] { + return pulumix.Output[IPAddressSpecPatch]{ + OutputState: i.ToIPAddressSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i IPAddressSpecPatchArgs) ToIPAddressSpecPatchPtrOutput() IPAddressSpecPatchPtrOutput { return i.ToIPAddressSpecPatchPtrOutputWithContext(context.Background()) } @@ -1207,6 +1382,12 @@ func (i *ipaddressSpecPatchPtrType) ToIPAddressSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IPAddressSpecPatchPtrOutput) } +func (i *ipaddressSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IPAddressSpecPatch] { + return pulumix.Output[*IPAddressSpecPatch]{ + OutputState: i.ToIPAddressSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IPAddressSpec describe the attributes in an IP Address. type IPAddressSpecPatchOutput struct{ *pulumi.OutputState } @@ -1232,6 +1413,12 @@ func (o IPAddressSpecPatchOutput) ToIPAddressSpecPatchPtrOutputWithContext(ctx c }).(IPAddressSpecPatchPtrOutput) } +func (o IPAddressSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IPAddressSpecPatch] { + return pulumix.Output[IPAddressSpecPatch]{ + OutputState: o.OutputState, + } +} + // ParentRef references the resource that an IPAddress is attached to. An IPAddress must reference a parent object. func (o IPAddressSpecPatchOutput) ParentRef() ParentReferencePatchPtrOutput { return o.ApplyT(func(v IPAddressSpecPatch) *ParentReferencePatch { return v.ParentRef }).(ParentReferencePatchPtrOutput) @@ -1251,6 +1438,12 @@ func (o IPAddressSpecPatchPtrOutput) ToIPAddressSpecPatchPtrOutputWithContext(ct return o } +func (o IPAddressSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IPAddressSpecPatch] { + return pulumix.Output[*IPAddressSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o IPAddressSpecPatchPtrOutput) Elem() IPAddressSpecPatchOutput { return o.ApplyT(func(v *IPAddressSpecPatch) IPAddressSpecPatch { if v != nil { @@ -1322,6 +1515,12 @@ func (i ParentReferenceArgs) ToParentReferenceOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ParentReferenceOutput) } +func (i ParentReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ParentReference] { + return pulumix.Output[ParentReference]{ + OutputState: i.ToParentReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ParentReferenceArgs) ToParentReferencePtrOutput() ParentReferencePtrOutput { return i.ToParentReferencePtrOutputWithContext(context.Background()) } @@ -1363,6 +1562,12 @@ func (i *parentReferencePtrType) ToParentReferencePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(ParentReferencePtrOutput) } +func (i *parentReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ParentReference] { + return pulumix.Output[*ParentReference]{ + OutputState: i.ToParentReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ParentReference describes a reference to a parent object. type ParentReferenceOutput struct{ *pulumi.OutputState } @@ -1388,6 +1593,12 @@ func (o ParentReferenceOutput) ToParentReferencePtrOutputWithContext(ctx context }).(ParentReferencePtrOutput) } +func (o ParentReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ParentReference] { + return pulumix.Output[ParentReference]{ + OutputState: o.OutputState, + } +} + // Group is the group of the object being referenced. func (o ParentReferenceOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v ParentReference) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -1427,6 +1638,12 @@ func (o ParentReferencePtrOutput) ToParentReferencePtrOutputWithContext(ctx cont return o } +func (o ParentReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParentReference] { + return pulumix.Output[*ParentReference]{ + OutputState: o.OutputState, + } +} + func (o ParentReferencePtrOutput) Elem() ParentReferenceOutput { return o.ApplyT(func(v *ParentReference) ParentReference { if v != nil { @@ -1538,6 +1755,12 @@ func (i ParentReferencePatchArgs) ToParentReferencePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ParentReferencePatchOutput) } +func (i ParentReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ParentReferencePatch] { + return pulumix.Output[ParentReferencePatch]{ + OutputState: i.ToParentReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ParentReferencePatchArgs) ToParentReferencePatchPtrOutput() ParentReferencePatchPtrOutput { return i.ToParentReferencePatchPtrOutputWithContext(context.Background()) } @@ -1579,6 +1802,12 @@ func (i *parentReferencePatchPtrType) ToParentReferencePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ParentReferencePatchPtrOutput) } +func (i *parentReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ParentReferencePatch] { + return pulumix.Output[*ParentReferencePatch]{ + OutputState: i.ToParentReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ParentReference describes a reference to a parent object. type ParentReferencePatchOutput struct{ *pulumi.OutputState } @@ -1604,6 +1833,12 @@ func (o ParentReferencePatchOutput) ToParentReferencePatchPtrOutputWithContext(c }).(ParentReferencePatchPtrOutput) } +func (o ParentReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ParentReferencePatch] { + return pulumix.Output[ParentReferencePatch]{ + OutputState: o.OutputState, + } +} + // Group is the group of the object being referenced. func (o ParentReferencePatchOutput) Group() pulumi.StringPtrOutput { return o.ApplyT(func(v ParentReferencePatch) *string { return v.Group }).(pulumi.StringPtrOutput) @@ -1643,6 +1878,12 @@ func (o ParentReferencePatchPtrOutput) ToParentReferencePatchPtrOutputWithContex return o } +func (o ParentReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ParentReferencePatch] { + return pulumix.Output[*ParentReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ParentReferencePatchPtrOutput) Elem() ParentReferencePatchOutput { return o.ApplyT(func(v *ParentReferencePatch) ParentReferencePatch { if v != nil { diff --git a/sdk/go/kubernetes/networking/v1beta1/ingress.go b/sdk/go/kubernetes/networking/v1beta1/ingress.go index 534b66e589..fcc5381f2d 100644 --- a/sdk/go/kubernetes/networking/v1beta1/ingress.go +++ b/sdk/go/kubernetes/networking/v1beta1/ingress.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. @@ -138,6 +139,12 @@ func (i *Ingress) ToIngressOutputWithContext(ctx context.Context) IngressOutput return pulumi.ToOutputWithContext(ctx, i).(IngressOutput) } +func (i *Ingress) ToOutput(ctx context.Context) pulumix.Output[*Ingress] { + return pulumix.Output[*Ingress]{ + OutputState: i.ToIngressOutputWithContext(ctx).OutputState, + } +} + // IngressArrayInput is an input type that accepts IngressArray and IngressArrayOutput values. // You can construct a concrete instance of `IngressArrayInput` via: // @@ -163,6 +170,12 @@ func (i IngressArray) ToIngressArrayOutputWithContext(ctx context.Context) Ingre return pulumi.ToOutputWithContext(ctx, i).(IngressArrayOutput) } +func (i IngressArray) ToOutput(ctx context.Context) pulumix.Output[[]*Ingress] { + return pulumix.Output[[]*Ingress]{ + OutputState: i.ToIngressArrayOutputWithContext(ctx).OutputState, + } +} + // IngressMapInput is an input type that accepts IngressMap and IngressMapOutput values. // You can construct a concrete instance of `IngressMapInput` via: // @@ -188,6 +201,12 @@ func (i IngressMap) ToIngressMapOutputWithContext(ctx context.Context) IngressMa return pulumi.ToOutputWithContext(ctx, i).(IngressMapOutput) } +func (i IngressMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Ingress] { + return pulumix.Output[map[string]*Ingress]{ + OutputState: i.ToIngressMapOutputWithContext(ctx).OutputState, + } +} + type IngressOutput struct{ *pulumi.OutputState } func (IngressOutput) ElementType() reflect.Type { @@ -202,6 +221,12 @@ func (o IngressOutput) ToIngressOutputWithContext(ctx context.Context) IngressOu return o } +func (o IngressOutput) ToOutput(ctx context.Context) pulumix.Output[*Ingress] { + return pulumix.Output[*Ingress]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Ingress) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -241,6 +266,12 @@ func (o IngressArrayOutput) ToIngressArrayOutputWithContext(ctx context.Context) return o } +func (o IngressArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Ingress] { + return pulumix.Output[[]*Ingress]{ + OutputState: o.OutputState, + } +} + func (o IngressArrayOutput) Index(i pulumi.IntInput) IngressOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Ingress { return vs[0].([]*Ingress)[vs[1].(int)] @@ -261,6 +292,12 @@ func (o IngressMapOutput) ToIngressMapOutputWithContext(ctx context.Context) Ing return o } +func (o IngressMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Ingress] { + return pulumix.Output[map[string]*Ingress]{ + OutputState: o.OutputState, + } +} + func (o IngressMapOutput) MapIndex(k pulumi.StringInput) IngressOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Ingress { return vs[0].(map[string]*Ingress)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1beta1/ingressClass.go b/sdk/go/kubernetes/networking/v1beta1/ingressClass.go index cc12fa3310..26e9531166 100644 --- a/sdk/go/kubernetes/networking/v1beta1/ingressClass.go +++ b/sdk/go/kubernetes/networking/v1beta1/ingressClass.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. @@ -119,6 +120,12 @@ func (i *IngressClass) ToIngressClassOutputWithContext(ctx context.Context) Ingr return pulumi.ToOutputWithContext(ctx, i).(IngressClassOutput) } +func (i *IngressClass) ToOutput(ctx context.Context) pulumix.Output[*IngressClass] { + return pulumix.Output[*IngressClass]{ + OutputState: i.ToIngressClassOutputWithContext(ctx).OutputState, + } +} + // IngressClassArrayInput is an input type that accepts IngressClassArray and IngressClassArrayOutput values. // You can construct a concrete instance of `IngressClassArrayInput` via: // @@ -144,6 +151,12 @@ func (i IngressClassArray) ToIngressClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressClassArrayOutput) } +func (i IngressClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClass] { + return pulumix.Output[[]*IngressClass]{ + OutputState: i.ToIngressClassArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClassMapInput is an input type that accepts IngressClassMap and IngressClassMapOutput values. // You can construct a concrete instance of `IngressClassMapInput` via: // @@ -169,6 +182,12 @@ func (i IngressClassMap) ToIngressClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressClassMapOutput) } +func (i IngressClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClass] { + return pulumix.Output[map[string]*IngressClass]{ + OutputState: i.ToIngressClassMapOutputWithContext(ctx).OutputState, + } +} + type IngressClassOutput struct{ *pulumi.OutputState } func (IngressClassOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o IngressClassOutput) ToIngressClassOutputWithContext(ctx context.Context) return o } +func (o IngressClassOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClass] { + return pulumix.Output[*IngressClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o IngressClassArrayOutput) ToIngressClassArrayOutputWithContext(ctx contex return o } +func (o IngressClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClass] { + return pulumix.Output[[]*IngressClass]{ + OutputState: o.OutputState, + } +} + func (o IngressClassArrayOutput) Index(i pulumi.IntInput) IngressClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressClass { return vs[0].([]*IngressClass)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o IngressClassMapOutput) ToIngressClassMapOutputWithContext(ctx context.Co return o } +func (o IngressClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClass] { + return pulumix.Output[map[string]*IngressClass]{ + OutputState: o.OutputState, + } +} + func (o IngressClassMapOutput) MapIndex(k pulumi.StringInput) IngressClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressClass { return vs[0].(map[string]*IngressClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1beta1/ingressClassList.go b/sdk/go/kubernetes/networking/v1beta1/ingressClassList.go index 999870faee..3c33b7675c 100644 --- a/sdk/go/kubernetes/networking/v1beta1/ingressClassList.go +++ b/sdk/go/kubernetes/networking/v1beta1/ingressClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressClassList is a collection of IngressClasses. @@ -117,6 +118,12 @@ func (i *IngressClassList) ToIngressClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(IngressClassListOutput) } +func (i *IngressClassList) ToOutput(ctx context.Context) pulumix.Output[*IngressClassList] { + return pulumix.Output[*IngressClassList]{ + OutputState: i.ToIngressClassListOutputWithContext(ctx).OutputState, + } +} + // IngressClassListArrayInput is an input type that accepts IngressClassListArray and IngressClassListArrayOutput values. // You can construct a concrete instance of `IngressClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i IngressClassListArray) ToIngressClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressClassListArrayOutput) } +func (i IngressClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassList] { + return pulumix.Output[[]*IngressClassList]{ + OutputState: i.ToIngressClassListArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClassListMapInput is an input type that accepts IngressClassListMap and IngressClassListMapOutput values. // You can construct a concrete instance of `IngressClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i IngressClassListMap) ToIngressClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(IngressClassListMapOutput) } +func (i IngressClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassList] { + return pulumix.Output[map[string]*IngressClassList]{ + OutputState: i.ToIngressClassListMapOutputWithContext(ctx).OutputState, + } +} + type IngressClassListOutput struct{ *pulumi.OutputState } func (IngressClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o IngressClassListOutput) ToIngressClassListOutputWithContext(ctx context. return o } +func (o IngressClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassList] { + return pulumix.Output[*IngressClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o IngressClassListArrayOutput) ToIngressClassListArrayOutputWithContext(ct return o } +func (o IngressClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassList] { + return pulumix.Output[[]*IngressClassList]{ + OutputState: o.OutputState, + } +} + func (o IngressClassListArrayOutput) Index(i pulumi.IntInput) IngressClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressClassList { return vs[0].([]*IngressClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o IngressClassListMapOutput) ToIngressClassListMapOutputWithContext(ctx co return o } +func (o IngressClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassList] { + return pulumix.Output[map[string]*IngressClassList]{ + OutputState: o.OutputState, + } +} + func (o IngressClassListMapOutput) MapIndex(k pulumi.StringInput) IngressClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressClassList { return vs[0].(map[string]*IngressClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1beta1/ingressClassPatch.go b/sdk/go/kubernetes/networking/v1beta1/ingressClassPatch.go index 23e49cf2d4..1a144f2529 100644 --- a/sdk/go/kubernetes/networking/v1beta1/ingressClassPatch.go +++ b/sdk/go/kubernetes/networking/v1beta1/ingressClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *IngressClassPatch) ToIngressClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchOutput) } +func (i *IngressClassPatch) ToOutput(ctx context.Context) pulumix.Output[*IngressClassPatch] { + return pulumix.Output[*IngressClassPatch]{ + OutputState: i.ToIngressClassPatchOutputWithContext(ctx).OutputState, + } +} + // IngressClassPatchArrayInput is an input type that accepts IngressClassPatchArray and IngressClassPatchArrayOutput values. // You can construct a concrete instance of `IngressClassPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i IngressClassPatchArray) ToIngressClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchArrayOutput) } +func (i IngressClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassPatch] { + return pulumix.Output[[]*IngressClassPatch]{ + OutputState: i.ToIngressClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClassPatchMapInput is an input type that accepts IngressClassPatchMap and IngressClassPatchMapOutput values. // You can construct a concrete instance of `IngressClassPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i IngressClassPatchMap) ToIngressClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchMapOutput) } +func (i IngressClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassPatch] { + return pulumix.Output[map[string]*IngressClassPatch]{ + OutputState: i.ToIngressClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type IngressClassPatchOutput struct{ *pulumi.OutputState } func (IngressClassPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o IngressClassPatchOutput) ToIngressClassPatchOutputWithContext(ctx contex return o } +func (o IngressClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassPatch] { + return pulumix.Output[*IngressClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *IngressClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o IngressClassPatchArrayOutput) ToIngressClassPatchArrayOutputWithContext( return o } +func (o IngressClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressClassPatch] { + return pulumix.Output[[]*IngressClassPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassPatchArrayOutput) Index(i pulumi.IntInput) IngressClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressClassPatch { return vs[0].([]*IngressClassPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o IngressClassPatchMapOutput) ToIngressClassPatchMapOutputWithContext(ctx return o } +func (o IngressClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressClassPatch] { + return pulumix.Output[map[string]*IngressClassPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassPatchMapOutput) MapIndex(k pulumi.StringInput) IngressClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressClassPatch { return vs[0].(map[string]*IngressClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1beta1/ingressList.go b/sdk/go/kubernetes/networking/v1beta1/ingressList.go index e72b2d9891..f5f98f384b 100644 --- a/sdk/go/kubernetes/networking/v1beta1/ingressList.go +++ b/sdk/go/kubernetes/networking/v1beta1/ingressList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // IngressList is a collection of Ingress. @@ -117,6 +118,12 @@ func (i *IngressList) ToIngressListOutputWithContext(ctx context.Context) Ingres return pulumi.ToOutputWithContext(ctx, i).(IngressListOutput) } +func (i *IngressList) ToOutput(ctx context.Context) pulumix.Output[*IngressList] { + return pulumix.Output[*IngressList]{ + OutputState: i.ToIngressListOutputWithContext(ctx).OutputState, + } +} + // IngressListArrayInput is an input type that accepts IngressListArray and IngressListArrayOutput values. // You can construct a concrete instance of `IngressListArrayInput` via: // @@ -142,6 +149,12 @@ func (i IngressListArray) ToIngressListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressListArrayOutput) } +func (i IngressListArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressList] { + return pulumix.Output[[]*IngressList]{ + OutputState: i.ToIngressListArrayOutputWithContext(ctx).OutputState, + } +} + // IngressListMapInput is an input type that accepts IngressListMap and IngressListMapOutput values. // You can construct a concrete instance of `IngressListMapInput` via: // @@ -167,6 +180,12 @@ func (i IngressListMap) ToIngressListMapOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IngressListMapOutput) } +func (i IngressListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressList] { + return pulumix.Output[map[string]*IngressList]{ + OutputState: i.ToIngressListMapOutputWithContext(ctx).OutputState, + } +} + type IngressListOutput struct{ *pulumi.OutputState } func (IngressListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o IngressListOutput) ToIngressListOutputWithContext(ctx context.Context) I return o } +func (o IngressListOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressList] { + return pulumix.Output[*IngressList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *IngressList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o IngressListArrayOutput) ToIngressListArrayOutputWithContext(ctx context. return o } +func (o IngressListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressList] { + return pulumix.Output[[]*IngressList]{ + OutputState: o.OutputState, + } +} + func (o IngressListArrayOutput) Index(i pulumi.IntInput) IngressListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressList { return vs[0].([]*IngressList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o IngressListMapOutput) ToIngressListMapOutputWithContext(ctx context.Cont return o } +func (o IngressListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressList] { + return pulumix.Output[map[string]*IngressList]{ + OutputState: o.OutputState, + } +} + func (o IngressListMapOutput) MapIndex(k pulumi.StringInput) IngressListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressList { return vs[0].(map[string]*IngressList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1beta1/ingressPatch.go b/sdk/go/kubernetes/networking/v1beta1/ingressPatch.go index 0aca36021e..a877269bed 100644 --- a/sdk/go/kubernetes/networking/v1beta1/ingressPatch.go +++ b/sdk/go/kubernetes/networking/v1beta1/ingressPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -144,6 +145,12 @@ func (i *IngressPatch) ToIngressPatchOutputWithContext(ctx context.Context) Ingr return pulumi.ToOutputWithContext(ctx, i).(IngressPatchOutput) } +func (i *IngressPatch) ToOutput(ctx context.Context) pulumix.Output[*IngressPatch] { + return pulumix.Output[*IngressPatch]{ + OutputState: i.ToIngressPatchOutputWithContext(ctx).OutputState, + } +} + // IngressPatchArrayInput is an input type that accepts IngressPatchArray and IngressPatchArrayOutput values. // You can construct a concrete instance of `IngressPatchArrayInput` via: // @@ -169,6 +176,12 @@ func (i IngressPatchArray) ToIngressPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressPatchArrayOutput) } +func (i IngressPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*IngressPatch] { + return pulumix.Output[[]*IngressPatch]{ + OutputState: i.ToIngressPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressPatchMapInput is an input type that accepts IngressPatchMap and IngressPatchMapOutput values. // You can construct a concrete instance of `IngressPatchMapInput` via: // @@ -194,6 +207,12 @@ func (i IngressPatchMap) ToIngressPatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressPatchMapOutput) } +func (i IngressPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressPatch] { + return pulumix.Output[map[string]*IngressPatch]{ + OutputState: i.ToIngressPatchMapOutputWithContext(ctx).OutputState, + } +} + type IngressPatchOutput struct{ *pulumi.OutputState } func (IngressPatchOutput) ElementType() reflect.Type { @@ -208,6 +227,12 @@ func (o IngressPatchOutput) ToIngressPatchOutputWithContext(ctx context.Context) return o } +func (o IngressPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressPatch] { + return pulumix.Output[*IngressPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *IngressPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -247,6 +272,12 @@ func (o IngressPatchArrayOutput) ToIngressPatchArrayOutputWithContext(ctx contex return o } +func (o IngressPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IngressPatch] { + return pulumix.Output[[]*IngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPatchArrayOutput) Index(i pulumi.IntInput) IngressPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IngressPatch { return vs[0].([]*IngressPatch)[vs[1].(int)] @@ -267,6 +298,12 @@ func (o IngressPatchMapOutput) ToIngressPatchMapOutputWithContext(ctx context.Co return o } +func (o IngressPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IngressPatch] { + return pulumix.Output[map[string]*IngressPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressPatchMapOutput) MapIndex(k pulumi.StringInput) IngressPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IngressPatch { return vs[0].(map[string]*IngressPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/networking/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/networking/v1beta1/pulumiTypes.go index c4db504f52..0f56ae0506 100644 --- a/sdk/go/kubernetes/networking/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/networking/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -78,6 +79,12 @@ func (i HTTPIngressPathArgs) ToHTTPIngressPathOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathOutput) } +func (i HTTPIngressPathArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPath] { + return pulumix.Output[HTTPIngressPath]{ + OutputState: i.ToHTTPIngressPathOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPathArrayInput is an input type that accepts HTTPIngressPathArray and HTTPIngressPathArrayOutput values. // You can construct a concrete instance of `HTTPIngressPathArrayInput` via: // @@ -103,6 +110,12 @@ func (i HTTPIngressPathArray) ToHTTPIngressPathArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathArrayOutput) } +func (i HTTPIngressPathArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPath] { + return pulumix.Output[[]HTTPIngressPath]{ + OutputState: i.ToHTTPIngressPathArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. type HTTPIngressPathOutput struct{ *pulumi.OutputState } @@ -118,6 +131,12 @@ func (o HTTPIngressPathOutput) ToHTTPIngressPathOutputWithContext(ctx context.Co return o } +func (o HTTPIngressPathOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPath] { + return pulumix.Output[HTTPIngressPath]{ + OutputState: o.OutputState, + } +} + // Backend defines the referenced service endpoint to which the traffic will be forwarded to. func (o HTTPIngressPathOutput) Backend() IngressBackendOutput { return o.ApplyT(func(v HTTPIngressPath) IngressBackend { return v.Backend }).(IngressBackendOutput) @@ -158,6 +177,12 @@ func (o HTTPIngressPathArrayOutput) ToHTTPIngressPathArrayOutputWithContext(ctx return o } +func (o HTTPIngressPathArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPath] { + return pulumix.Output[[]HTTPIngressPath]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressPathArrayOutput) Index(i pulumi.IntInput) HTTPIngressPathOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPIngressPath { return vs[0].([]HTTPIngressPath)[vs[1].(int)] @@ -227,6 +252,12 @@ func (i HTTPIngressPathPatchArgs) ToHTTPIngressPathPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathPatchOutput) } +func (i HTTPIngressPathPatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPathPatch] { + return pulumix.Output[HTTPIngressPathPatch]{ + OutputState: i.ToHTTPIngressPathPatchOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPathPatchArrayInput is an input type that accepts HTTPIngressPathPatchArray and HTTPIngressPathPatchArrayOutput values. // You can construct a concrete instance of `HTTPIngressPathPatchArrayInput` via: // @@ -252,6 +283,12 @@ func (i HTTPIngressPathPatchArray) ToHTTPIngressPathPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressPathPatchArrayOutput) } +func (i HTTPIngressPathPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPathPatch] { + return pulumix.Output[[]HTTPIngressPathPatch]{ + OutputState: i.ToHTTPIngressPathPatchArrayOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. type HTTPIngressPathPatchOutput struct{ *pulumi.OutputState } @@ -267,6 +304,12 @@ func (o HTTPIngressPathPatchOutput) ToHTTPIngressPathPatchOutputWithContext(ctx return o } +func (o HTTPIngressPathPatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressPathPatch] { + return pulumix.Output[HTTPIngressPathPatch]{ + OutputState: o.OutputState, + } +} + // Backend defines the referenced service endpoint to which the traffic will be forwarded to. func (o HTTPIngressPathPatchOutput) Backend() IngressBackendPatchPtrOutput { return o.ApplyT(func(v HTTPIngressPathPatch) *IngressBackendPatch { return v.Backend }).(IngressBackendPatchPtrOutput) @@ -307,6 +350,12 @@ func (o HTTPIngressPathPatchArrayOutput) ToHTTPIngressPathPatchArrayOutputWithCo return o } +func (o HTTPIngressPathPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HTTPIngressPathPatch] { + return pulumix.Output[[]HTTPIngressPathPatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressPathPatchArrayOutput) Index(i pulumi.IntInput) HTTPIngressPathPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HTTPIngressPathPatch { return vs[0].([]HTTPIngressPathPatch)[vs[1].(int)] @@ -348,6 +397,12 @@ func (i HTTPIngressRuleValueArgs) ToHTTPIngressRuleValueOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValueOutput) } +func (i HTTPIngressRuleValueArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValue] { + return pulumix.Output[HTTPIngressRuleValue]{ + OutputState: i.ToHTTPIngressRuleValueOutputWithContext(ctx).OutputState, + } +} + func (i HTTPIngressRuleValueArgs) ToHTTPIngressRuleValuePtrOutput() HTTPIngressRuleValuePtrOutput { return i.ToHTTPIngressRuleValuePtrOutputWithContext(context.Background()) } @@ -389,6 +444,12 @@ func (i *httpingressRuleValuePtrType) ToHTTPIngressRuleValuePtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePtrOutput) } +func (i *httpingressRuleValuePtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValue] { + return pulumix.Output[*HTTPIngressRuleValue]{ + OutputState: i.ToHTTPIngressRuleValuePtrOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. type HTTPIngressRuleValueOutput struct{ *pulumi.OutputState } @@ -414,6 +475,12 @@ func (o HTTPIngressRuleValueOutput) ToHTTPIngressRuleValuePtrOutputWithContext(c }).(HTTPIngressRuleValuePtrOutput) } +func (o HTTPIngressRuleValueOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValue] { + return pulumix.Output[HTTPIngressRuleValue]{ + OutputState: o.OutputState, + } +} + // A collection of paths that map requests to backends. func (o HTTPIngressRuleValueOutput) Paths() HTTPIngressPathArrayOutput { return o.ApplyT(func(v HTTPIngressRuleValue) []HTTPIngressPath { return v.Paths }).(HTTPIngressPathArrayOutput) @@ -433,6 +500,12 @@ func (o HTTPIngressRuleValuePtrOutput) ToHTTPIngressRuleValuePtrOutputWithContex return o } +func (o HTTPIngressRuleValuePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValue] { + return pulumix.Output[*HTTPIngressRuleValue]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressRuleValuePtrOutput) Elem() HTTPIngressRuleValueOutput { return o.ApplyT(func(v *HTTPIngressRuleValue) HTTPIngressRuleValue { if v != nil { @@ -488,6 +561,12 @@ func (i HTTPIngressRuleValuePatchArgs) ToHTTPIngressRuleValuePatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePatchOutput) } +func (i HTTPIngressRuleValuePatchArgs) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValuePatch] { + return pulumix.Output[HTTPIngressRuleValuePatch]{ + OutputState: i.ToHTTPIngressRuleValuePatchOutputWithContext(ctx).OutputState, + } +} + func (i HTTPIngressRuleValuePatchArgs) ToHTTPIngressRuleValuePatchPtrOutput() HTTPIngressRuleValuePatchPtrOutput { return i.ToHTTPIngressRuleValuePatchPtrOutputWithContext(context.Background()) } @@ -529,6 +608,12 @@ func (i *httpingressRuleValuePatchPtrType) ToHTTPIngressRuleValuePatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(HTTPIngressRuleValuePatchPtrOutput) } +func (i *httpingressRuleValuePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValuePatch] { + return pulumix.Output[*HTTPIngressRuleValuePatch]{ + OutputState: i.ToHTTPIngressRuleValuePatchPtrOutputWithContext(ctx).OutputState, + } +} + // HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. type HTTPIngressRuleValuePatchOutput struct{ *pulumi.OutputState } @@ -554,6 +639,12 @@ func (o HTTPIngressRuleValuePatchOutput) ToHTTPIngressRuleValuePatchPtrOutputWit }).(HTTPIngressRuleValuePatchPtrOutput) } +func (o HTTPIngressRuleValuePatchOutput) ToOutput(ctx context.Context) pulumix.Output[HTTPIngressRuleValuePatch] { + return pulumix.Output[HTTPIngressRuleValuePatch]{ + OutputState: o.OutputState, + } +} + // A collection of paths that map requests to backends. func (o HTTPIngressRuleValuePatchOutput) Paths() HTTPIngressPathPatchArrayOutput { return o.ApplyT(func(v HTTPIngressRuleValuePatch) []HTTPIngressPathPatch { return v.Paths }).(HTTPIngressPathPatchArrayOutput) @@ -573,6 +664,12 @@ func (o HTTPIngressRuleValuePatchPtrOutput) ToHTTPIngressRuleValuePatchPtrOutput return o } +func (o HTTPIngressRuleValuePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HTTPIngressRuleValuePatch] { + return pulumix.Output[*HTTPIngressRuleValuePatch]{ + OutputState: o.OutputState, + } +} + func (o HTTPIngressRuleValuePatchPtrOutput) Elem() HTTPIngressRuleValuePatchOutput { return o.ApplyT(func(v *HTTPIngressRuleValuePatch) HTTPIngressRuleValuePatch { if v != nil { @@ -672,6 +769,12 @@ func (i IngressTypeArgs) ToIngressTypeOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressTypeOutput) } +func (i IngressTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressType] { + return pulumix.Output[IngressType]{ + OutputState: i.ToIngressTypeOutputWithContext(ctx).OutputState, + } +} + // IngressTypeArrayInput is an input type that accepts IngressTypeArray and IngressTypeArrayOutput values. // You can construct a concrete instance of `IngressTypeArrayInput` via: // @@ -697,6 +800,12 @@ func (i IngressTypeArray) ToIngressTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressTypeArrayOutput) } +func (i IngressTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressType] { + return pulumix.Output[[]IngressType]{ + OutputState: i.ToIngressTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. // // This resource waits until its status is ready before registering success @@ -726,6 +835,12 @@ func (o IngressTypeOutput) ToIngressTypeOutputWithContext(ctx context.Context) I return o } +func (o IngressTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressType] { + return pulumix.Output[IngressType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -765,6 +880,12 @@ func (o IngressTypeArrayOutput) ToIngressTypeArrayOutputWithContext(ctx context. return o } +func (o IngressTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressType] { + return pulumix.Output[[]IngressType]{ + OutputState: o.OutputState, + } +} + func (o IngressTypeArrayOutput) Index(i pulumi.IntInput) IngressTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressType { return vs[0].([]IngressType)[vs[1].(int)] @@ -814,6 +935,12 @@ func (i IngressBackendArgs) ToIngressBackendOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressBackendOutput) } +func (i IngressBackendArgs) ToOutput(ctx context.Context) pulumix.Output[IngressBackend] { + return pulumix.Output[IngressBackend]{ + OutputState: i.ToIngressBackendOutputWithContext(ctx).OutputState, + } +} + func (i IngressBackendArgs) ToIngressBackendPtrOutput() IngressBackendPtrOutput { return i.ToIngressBackendPtrOutputWithContext(context.Background()) } @@ -855,6 +982,12 @@ func (i *ingressBackendPtrType) ToIngressBackendPtrOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPtrOutput) } +func (i *ingressBackendPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressBackend] { + return pulumix.Output[*IngressBackend]{ + OutputState: i.ToIngressBackendPtrOutputWithContext(ctx).OutputState, + } +} + // IngressBackend describes all endpoints for a given service and port. type IngressBackendOutput struct{ *pulumi.OutputState } @@ -880,6 +1013,12 @@ func (o IngressBackendOutput) ToIngressBackendPtrOutputWithContext(ctx context.C }).(IngressBackendPtrOutput) } +func (o IngressBackendOutput) ToOutput(ctx context.Context) pulumix.Output[IngressBackend] { + return pulumix.Output[IngressBackend]{ + OutputState: o.OutputState, + } +} + // Resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, serviceName and servicePort must not be specified. func (o IngressBackendOutput) Resource() corev1.TypedLocalObjectReferencePtrOutput { return o.ApplyT(func(v IngressBackend) *corev1.TypedLocalObjectReference { return v.Resource }).(corev1.TypedLocalObjectReferencePtrOutput) @@ -909,6 +1048,12 @@ func (o IngressBackendPtrOutput) ToIngressBackendPtrOutputWithContext(ctx contex return o } +func (o IngressBackendPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressBackend] { + return pulumix.Output[*IngressBackend]{ + OutputState: o.OutputState, + } +} + func (o IngressBackendPtrOutput) Elem() IngressBackendOutput { return o.ApplyT(func(v *IngressBackend) IngressBackend { if v != nil { @@ -992,6 +1137,12 @@ func (i IngressBackendPatchArgs) ToIngressBackendPatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPatchOutput) } +func (i IngressBackendPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressBackendPatch] { + return pulumix.Output[IngressBackendPatch]{ + OutputState: i.ToIngressBackendPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressBackendPatchArgs) ToIngressBackendPatchPtrOutput() IngressBackendPatchPtrOutput { return i.ToIngressBackendPatchPtrOutputWithContext(context.Background()) } @@ -1033,6 +1184,12 @@ func (i *ingressBackendPatchPtrType) ToIngressBackendPatchPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(IngressBackendPatchPtrOutput) } +func (i *ingressBackendPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressBackendPatch] { + return pulumix.Output[*IngressBackendPatch]{ + OutputState: i.ToIngressBackendPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressBackend describes all endpoints for a given service and port. type IngressBackendPatchOutput struct{ *pulumi.OutputState } @@ -1058,6 +1215,12 @@ func (o IngressBackendPatchOutput) ToIngressBackendPatchPtrOutputWithContext(ctx }).(IngressBackendPatchPtrOutput) } +func (o IngressBackendPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressBackendPatch] { + return pulumix.Output[IngressBackendPatch]{ + OutputState: o.OutputState, + } +} + // Resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, serviceName and servicePort must not be specified. func (o IngressBackendPatchOutput) Resource() corev1.TypedLocalObjectReferencePatchPtrOutput { return o.ApplyT(func(v IngressBackendPatch) *corev1.TypedLocalObjectReferencePatch { return v.Resource }).(corev1.TypedLocalObjectReferencePatchPtrOutput) @@ -1087,6 +1250,12 @@ func (o IngressBackendPatchPtrOutput) ToIngressBackendPatchPtrOutputWithContext( return o } +func (o IngressBackendPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressBackendPatch] { + return pulumix.Output[*IngressBackendPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressBackendPatchPtrOutput) Elem() IngressBackendPatchOutput { return o.ApplyT(func(v *IngressBackendPatch) IngressBackendPatch { if v != nil { @@ -1174,6 +1343,12 @@ func (i IngressClassTypeArgs) ToIngressClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressClassTypeOutput) } +func (i IngressClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassType] { + return pulumix.Output[IngressClassType]{ + OutputState: i.ToIngressClassTypeOutputWithContext(ctx).OutputState, + } +} + // IngressClassTypeArrayInput is an input type that accepts IngressClassTypeArray and IngressClassTypeArrayOutput values. // You can construct a concrete instance of `IngressClassTypeArrayInput` via: // @@ -1199,6 +1374,12 @@ func (i IngressClassTypeArray) ToIngressClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressClassTypeArrayOutput) } +func (i IngressClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressClassType] { + return pulumix.Output[[]IngressClassType]{ + OutputState: i.ToIngressClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. type IngressClassTypeOutput struct{ *pulumi.OutputState } @@ -1214,6 +1395,12 @@ func (o IngressClassTypeOutput) ToIngressClassTypeOutputWithContext(ctx context. return o } +func (o IngressClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassType] { + return pulumix.Output[IngressClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1248,6 +1435,12 @@ func (o IngressClassTypeArrayOutput) ToIngressClassTypeArrayOutputWithContext(ct return o } +func (o IngressClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressClassType] { + return pulumix.Output[[]IngressClassType]{ + OutputState: o.OutputState, + } +} + func (o IngressClassTypeArrayOutput) Index(i pulumi.IntInput) IngressClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressClassType { return vs[0].([]IngressClassType)[vs[1].(int)] @@ -1301,6 +1494,12 @@ func (i IngressClassListTypeArgs) ToIngressClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(IngressClassListTypeOutput) } +func (i IngressClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassListType] { + return pulumix.Output[IngressClassListType]{ + OutputState: i.ToIngressClassListTypeOutputWithContext(ctx).OutputState, + } +} + // IngressClassList is a collection of IngressClasses. type IngressClassListTypeOutput struct{ *pulumi.OutputState } @@ -1316,6 +1515,12 @@ func (o IngressClassListTypeOutput) ToIngressClassListTypeOutputWithContext(ctx return o } +func (o IngressClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassListType] { + return pulumix.Output[IngressClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1383,6 +1588,12 @@ func (i IngressClassPatchTypeArgs) ToIngressClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressClassPatchTypeOutput) } +func (i IngressClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassPatchType] { + return pulumix.Output[IngressClassPatchType]{ + OutputState: i.ToIngressClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. type IngressClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -1398,6 +1609,12 @@ func (o IngressClassPatchTypeOutput) ToIngressClassPatchTypeOutputWithContext(ct return o } +func (o IngressClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassPatchType] { + return pulumix.Output[IngressClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1457,6 +1674,12 @@ func (i IngressClassSpecArgs) ToIngressClassSpecOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecOutput) } +func (i IngressClassSpecArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpec] { + return pulumix.Output[IngressClassSpec]{ + OutputState: i.ToIngressClassSpecOutputWithContext(ctx).OutputState, + } +} + func (i IngressClassSpecArgs) ToIngressClassSpecPtrOutput() IngressClassSpecPtrOutput { return i.ToIngressClassSpecPtrOutputWithContext(context.Background()) } @@ -1498,6 +1721,12 @@ func (i *ingressClassSpecPtrType) ToIngressClassSpecPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecPtrOutput) } +func (i *ingressClassSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpec] { + return pulumix.Output[*IngressClassSpec]{ + OutputState: i.ToIngressClassSpecPtrOutputWithContext(ctx).OutputState, + } +} + // IngressClassSpec provides information about the class of an Ingress. type IngressClassSpecOutput struct{ *pulumi.OutputState } @@ -1523,6 +1752,12 @@ func (o IngressClassSpecOutput) ToIngressClassSpecPtrOutputWithContext(ctx conte }).(IngressClassSpecPtrOutput) } +func (o IngressClassSpecOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpec] { + return pulumix.Output[IngressClassSpec]{ + OutputState: o.OutputState, + } +} + // Controller refers to the name of the controller that should handle this class. This allows for different "flavors" that are controlled by the same controller. For example, you may have different Parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. "acme.io/ingress-controller". This field is immutable. func (o IngressClassSpecOutput) Controller() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassSpec) *string { return v.Controller }).(pulumi.StringPtrOutput) @@ -1547,6 +1782,12 @@ func (o IngressClassSpecPtrOutput) ToIngressClassSpecPtrOutputWithContext(ctx co return o } +func (o IngressClassSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpec] { + return pulumix.Output[*IngressClassSpec]{ + OutputState: o.OutputState, + } +} + func (o IngressClassSpecPtrOutput) Elem() IngressClassSpecOutput { return o.ApplyT(func(v *IngressClassSpec) IngressClassSpec { if v != nil { @@ -1616,6 +1857,12 @@ func (i IngressClassSpecPatchArgs) ToIngressClassSpecPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecPatchOutput) } +func (i IngressClassSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpecPatch] { + return pulumix.Output[IngressClassSpecPatch]{ + OutputState: i.ToIngressClassSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressClassSpecPatchArgs) ToIngressClassSpecPatchPtrOutput() IngressClassSpecPatchPtrOutput { return i.ToIngressClassSpecPatchPtrOutputWithContext(context.Background()) } @@ -1657,6 +1904,12 @@ func (i *ingressClassSpecPatchPtrType) ToIngressClassSpecPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(IngressClassSpecPatchPtrOutput) } +func (i *ingressClassSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpecPatch] { + return pulumix.Output[*IngressClassSpecPatch]{ + OutputState: i.ToIngressClassSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressClassSpec provides information about the class of an Ingress. type IngressClassSpecPatchOutput struct{ *pulumi.OutputState } @@ -1682,6 +1935,12 @@ func (o IngressClassSpecPatchOutput) ToIngressClassSpecPatchPtrOutputWithContext }).(IngressClassSpecPatchPtrOutput) } +func (o IngressClassSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressClassSpecPatch] { + return pulumix.Output[IngressClassSpecPatch]{ + OutputState: o.OutputState, + } +} + // Controller refers to the name of the controller that should handle this class. This allows for different "flavors" that are controlled by the same controller. For example, you may have different Parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. "acme.io/ingress-controller". This field is immutable. func (o IngressClassSpecPatchOutput) Controller() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressClassSpecPatch) *string { return v.Controller }).(pulumi.StringPtrOutput) @@ -1706,6 +1965,12 @@ func (o IngressClassSpecPatchPtrOutput) ToIngressClassSpecPatchPtrOutputWithCont return o } +func (o IngressClassSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressClassSpecPatch] { + return pulumix.Output[*IngressClassSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressClassSpecPatchPtrOutput) Elem() IngressClassSpecPatchOutput { return o.ApplyT(func(v *IngressClassSpecPatch) IngressClassSpecPatch { if v != nil { @@ -1783,6 +2048,12 @@ func (i IngressListTypeArgs) ToIngressListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressListTypeOutput) } +func (i IngressListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressListType] { + return pulumix.Output[IngressListType]{ + OutputState: i.ToIngressListTypeOutputWithContext(ctx).OutputState, + } +} + // IngressList is a collection of Ingress. type IngressListTypeOutput struct{ *pulumi.OutputState } @@ -1798,6 +2069,12 @@ func (o IngressListTypeOutput) ToIngressListTypeOutputWithContext(ctx context.Co return o } +func (o IngressListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressListType] { + return pulumix.Output[IngressListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1897,6 +2174,12 @@ func (i IngressPatchTypeArgs) ToIngressPatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressPatchTypeOutput) } +func (i IngressPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[IngressPatchType] { + return pulumix.Output[IngressPatchType]{ + OutputState: i.ToIngressPatchTypeOutputWithContext(ctx).OutputState, + } +} + // Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. // // This resource waits until its status is ready before registering success @@ -1926,6 +2209,12 @@ func (o IngressPatchTypeOutput) ToIngressPatchTypeOutputWithContext(ctx context. return o } +func (o IngressPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[IngressPatchType] { + return pulumix.Output[IngressPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o IngressPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v IngressPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1998,6 +2287,12 @@ func (i IngressRuleArgs) ToIngressRuleOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressRuleOutput) } +func (i IngressRuleArgs) ToOutput(ctx context.Context) pulumix.Output[IngressRule] { + return pulumix.Output[IngressRule]{ + OutputState: i.ToIngressRuleOutputWithContext(ctx).OutputState, + } +} + // IngressRuleArrayInput is an input type that accepts IngressRuleArray and IngressRuleArrayOutput values. // You can construct a concrete instance of `IngressRuleArrayInput` via: // @@ -2023,6 +2318,12 @@ func (i IngressRuleArray) ToIngressRuleArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(IngressRuleArrayOutput) } +func (i IngressRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressRule] { + return pulumix.Output[[]IngressRule]{ + OutputState: i.ToIngressRuleArrayOutputWithContext(ctx).OutputState, + } +} + // IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. type IngressRuleOutput struct{ *pulumi.OutputState } @@ -2038,6 +2339,12 @@ func (o IngressRuleOutput) ToIngressRuleOutputWithContext(ctx context.Context) I return o } +func (o IngressRuleOutput) ToOutput(ctx context.Context) pulumix.Output[IngressRule] { + return pulumix.Output[IngressRule]{ + OutputState: o.OutputState, + } +} + // Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the // // IP in the Spec of the parent Ingress. @@ -2068,6 +2375,12 @@ func (o IngressRuleArrayOutput) ToIngressRuleArrayOutputWithContext(ctx context. return o } +func (o IngressRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressRule] { + return pulumix.Output[[]IngressRule]{ + OutputState: o.OutputState, + } +} + func (o IngressRuleArrayOutput) Index(i pulumi.IntInput) IngressRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressRule { return vs[0].([]IngressRule)[vs[1].(int)] @@ -2121,6 +2434,12 @@ func (i IngressRulePatchArgs) ToIngressRulePatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressRulePatchOutput) } +func (i IngressRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressRulePatch] { + return pulumix.Output[IngressRulePatch]{ + OutputState: i.ToIngressRulePatchOutputWithContext(ctx).OutputState, + } +} + // IngressRulePatchArrayInput is an input type that accepts IngressRulePatchArray and IngressRulePatchArrayOutput values. // You can construct a concrete instance of `IngressRulePatchArrayInput` via: // @@ -2146,6 +2465,12 @@ func (i IngressRulePatchArray) ToIngressRulePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(IngressRulePatchArrayOutput) } +func (i IngressRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressRulePatch] { + return pulumix.Output[[]IngressRulePatch]{ + OutputState: i.ToIngressRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. type IngressRulePatchOutput struct{ *pulumi.OutputState } @@ -2161,6 +2486,12 @@ func (o IngressRulePatchOutput) ToIngressRulePatchOutputWithContext(ctx context. return o } +func (o IngressRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressRulePatch] { + return pulumix.Output[IngressRulePatch]{ + OutputState: o.OutputState, + } +} + // Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the // // IP in the Spec of the parent Ingress. @@ -2191,6 +2522,12 @@ func (o IngressRulePatchArrayOutput) ToIngressRulePatchArrayOutputWithContext(ct return o } +func (o IngressRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressRulePatch] { + return pulumix.Output[[]IngressRulePatch]{ + OutputState: o.OutputState, + } +} + func (o IngressRulePatchArrayOutput) Index(i pulumi.IntInput) IngressRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressRulePatch { return vs[0].([]IngressRulePatch)[vs[1].(int)] @@ -2244,6 +2581,12 @@ func (i IngressSpecArgs) ToIngressSpecOutputWithContext(ctx context.Context) Ing return pulumi.ToOutputWithContext(ctx, i).(IngressSpecOutput) } +func (i IngressSpecArgs) ToOutput(ctx context.Context) pulumix.Output[IngressSpec] { + return pulumix.Output[IngressSpec]{ + OutputState: i.ToIngressSpecOutputWithContext(ctx).OutputState, + } +} + func (i IngressSpecArgs) ToIngressSpecPtrOutput() IngressSpecPtrOutput { return i.ToIngressSpecPtrOutputWithContext(context.Background()) } @@ -2285,6 +2628,12 @@ func (i *ingressSpecPtrType) ToIngressSpecPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPtrOutput) } +func (i *ingressSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressSpec] { + return pulumix.Output[*IngressSpec]{ + OutputState: i.ToIngressSpecPtrOutputWithContext(ctx).OutputState, + } +} + // IngressSpec describes the Ingress the user wishes to exist. type IngressSpecOutput struct{ *pulumi.OutputState } @@ -2310,6 +2659,12 @@ func (o IngressSpecOutput) ToIngressSpecPtrOutputWithContext(ctx context.Context }).(IngressSpecPtrOutput) } +func (o IngressSpecOutput) ToOutput(ctx context.Context) pulumix.Output[IngressSpec] { + return pulumix.Output[IngressSpec]{ + OutputState: o.OutputState, + } +} + // A default backend capable of servicing requests that don't match any rule. At least one of 'backend' or 'rules' must be specified. This field is optional to allow the loadbalancer controller or defaulting logic to specify a global default. func (o IngressSpecOutput) Backend() IngressBackendPtrOutput { return o.ApplyT(func(v IngressSpec) *IngressBackend { return v.Backend }).(IngressBackendPtrOutput) @@ -2344,6 +2699,12 @@ func (o IngressSpecPtrOutput) ToIngressSpecPtrOutputWithContext(ctx context.Cont return o } +func (o IngressSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressSpec] { + return pulumix.Output[*IngressSpec]{ + OutputState: o.OutputState, + } +} + func (o IngressSpecPtrOutput) Elem() IngressSpecOutput { return o.ApplyT(func(v *IngressSpec) IngressSpec { if v != nil { @@ -2441,6 +2802,12 @@ func (i IngressSpecPatchArgs) ToIngressSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPatchOutput) } +func (i IngressSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressSpecPatch] { + return pulumix.Output[IngressSpecPatch]{ + OutputState: i.ToIngressSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressSpecPatchArgs) ToIngressSpecPatchPtrOutput() IngressSpecPatchPtrOutput { return i.ToIngressSpecPatchPtrOutputWithContext(context.Background()) } @@ -2482,6 +2849,12 @@ func (i *ingressSpecPatchPtrType) ToIngressSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(IngressSpecPatchPtrOutput) } +func (i *ingressSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressSpecPatch] { + return pulumix.Output[*IngressSpecPatch]{ + OutputState: i.ToIngressSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressSpec describes the Ingress the user wishes to exist. type IngressSpecPatchOutput struct{ *pulumi.OutputState } @@ -2507,6 +2880,12 @@ func (o IngressSpecPatchOutput) ToIngressSpecPatchPtrOutputWithContext(ctx conte }).(IngressSpecPatchPtrOutput) } +func (o IngressSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressSpecPatch] { + return pulumix.Output[IngressSpecPatch]{ + OutputState: o.OutputState, + } +} + // A default backend capable of servicing requests that don't match any rule. At least one of 'backend' or 'rules' must be specified. This field is optional to allow the loadbalancer controller or defaulting logic to specify a global default. func (o IngressSpecPatchOutput) Backend() IngressBackendPatchPtrOutput { return o.ApplyT(func(v IngressSpecPatch) *IngressBackendPatch { return v.Backend }).(IngressBackendPatchPtrOutput) @@ -2541,6 +2920,12 @@ func (o IngressSpecPatchPtrOutput) ToIngressSpecPatchPtrOutputWithContext(ctx co return o } +func (o IngressSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressSpecPatch] { + return pulumix.Output[*IngressSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressSpecPatchPtrOutput) Elem() IngressSpecPatchOutput { return o.ApplyT(func(v *IngressSpecPatch) IngressSpecPatch { if v != nil { @@ -2626,6 +3011,12 @@ func (i IngressStatusArgs) ToIngressStatusOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressStatusOutput) } +func (i IngressStatusArgs) ToOutput(ctx context.Context) pulumix.Output[IngressStatus] { + return pulumix.Output[IngressStatus]{ + OutputState: i.ToIngressStatusOutputWithContext(ctx).OutputState, + } +} + func (i IngressStatusArgs) ToIngressStatusPtrOutput() IngressStatusPtrOutput { return i.ToIngressStatusPtrOutputWithContext(context.Background()) } @@ -2667,6 +3058,12 @@ func (i *ingressStatusPtrType) ToIngressStatusPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPtrOutput) } +func (i *ingressStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressStatus] { + return pulumix.Output[*IngressStatus]{ + OutputState: i.ToIngressStatusPtrOutputWithContext(ctx).OutputState, + } +} + // IngressStatus describe the current state of the Ingress. type IngressStatusOutput struct{ *pulumi.OutputState } @@ -2692,6 +3089,12 @@ func (o IngressStatusOutput) ToIngressStatusPtrOutputWithContext(ctx context.Con }).(IngressStatusPtrOutput) } +func (o IngressStatusOutput) ToOutput(ctx context.Context) pulumix.Output[IngressStatus] { + return pulumix.Output[IngressStatus]{ + OutputState: o.OutputState, + } +} + // LoadBalancer contains the current status of the load-balancer. func (o IngressStatusOutput) LoadBalancer() corev1.LoadBalancerStatusPtrOutput { return o.ApplyT(func(v IngressStatus) *corev1.LoadBalancerStatus { return v.LoadBalancer }).(corev1.LoadBalancerStatusPtrOutput) @@ -2711,6 +3114,12 @@ func (o IngressStatusPtrOutput) ToIngressStatusPtrOutputWithContext(ctx context. return o } +func (o IngressStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressStatus] { + return pulumix.Output[*IngressStatus]{ + OutputState: o.OutputState, + } +} + func (o IngressStatusPtrOutput) Elem() IngressStatusOutput { return o.ApplyT(func(v *IngressStatus) IngressStatus { if v != nil { @@ -2766,6 +3175,12 @@ func (i IngressStatusPatchArgs) ToIngressStatusPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPatchOutput) } +func (i IngressStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressStatusPatch] { + return pulumix.Output[IngressStatusPatch]{ + OutputState: i.ToIngressStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i IngressStatusPatchArgs) ToIngressStatusPatchPtrOutput() IngressStatusPatchPtrOutput { return i.ToIngressStatusPatchPtrOutputWithContext(context.Background()) } @@ -2807,6 +3222,12 @@ func (i *ingressStatusPatchPtrType) ToIngressStatusPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(IngressStatusPatchPtrOutput) } +func (i *ingressStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*IngressStatusPatch] { + return pulumix.Output[*IngressStatusPatch]{ + OutputState: i.ToIngressStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // IngressStatus describe the current state of the Ingress. type IngressStatusPatchOutput struct{ *pulumi.OutputState } @@ -2832,6 +3253,12 @@ func (o IngressStatusPatchOutput) ToIngressStatusPatchPtrOutputWithContext(ctx c }).(IngressStatusPatchPtrOutput) } +func (o IngressStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressStatusPatch] { + return pulumix.Output[IngressStatusPatch]{ + OutputState: o.OutputState, + } +} + // LoadBalancer contains the current status of the load-balancer. func (o IngressStatusPatchOutput) LoadBalancer() corev1.LoadBalancerStatusPatchPtrOutput { return o.ApplyT(func(v IngressStatusPatch) *corev1.LoadBalancerStatusPatch { return v.LoadBalancer }).(corev1.LoadBalancerStatusPatchPtrOutput) @@ -2851,6 +3278,12 @@ func (o IngressStatusPatchPtrOutput) ToIngressStatusPatchPtrOutputWithContext(ct return o } +func (o IngressStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*IngressStatusPatch] { + return pulumix.Output[*IngressStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressStatusPatchPtrOutput) Elem() IngressStatusPatchOutput { return o.ApplyT(func(v *IngressStatusPatch) IngressStatusPatch { if v != nil { @@ -2910,6 +3343,12 @@ func (i IngressTLSArgs) ToIngressTLSOutputWithContext(ctx context.Context) Ingre return pulumi.ToOutputWithContext(ctx, i).(IngressTLSOutput) } +func (i IngressTLSArgs) ToOutput(ctx context.Context) pulumix.Output[IngressTLS] { + return pulumix.Output[IngressTLS]{ + OutputState: i.ToIngressTLSOutputWithContext(ctx).OutputState, + } +} + // IngressTLSArrayInput is an input type that accepts IngressTLSArray and IngressTLSArrayOutput values. // You can construct a concrete instance of `IngressTLSArrayInput` via: // @@ -2935,6 +3374,12 @@ func (i IngressTLSArray) ToIngressTLSArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(IngressTLSArrayOutput) } +func (i IngressTLSArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLS] { + return pulumix.Output[[]IngressTLS]{ + OutputState: i.ToIngressTLSArrayOutputWithContext(ctx).OutputState, + } +} + // IngressTLS describes the transport layer security associated with an Ingress. type IngressTLSOutput struct{ *pulumi.OutputState } @@ -2950,6 +3395,12 @@ func (o IngressTLSOutput) ToIngressTLSOutputWithContext(ctx context.Context) Ing return o } +func (o IngressTLSOutput) ToOutput(ctx context.Context) pulumix.Output[IngressTLS] { + return pulumix.Output[IngressTLS]{ + OutputState: o.OutputState, + } +} + // Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. func (o IngressTLSOutput) Hosts() pulumi.StringArrayOutput { return o.ApplyT(func(v IngressTLS) []string { return v.Hosts }).(pulumi.StringArrayOutput) @@ -2974,6 +3425,12 @@ func (o IngressTLSArrayOutput) ToIngressTLSArrayOutputWithContext(ctx context.Co return o } +func (o IngressTLSArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLS] { + return pulumix.Output[[]IngressTLS]{ + OutputState: o.OutputState, + } +} + func (o IngressTLSArrayOutput) Index(i pulumi.IntInput) IngressTLSOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressTLS { return vs[0].([]IngressTLS)[vs[1].(int)] @@ -3019,6 +3476,12 @@ func (i IngressTLSPatchArgs) ToIngressTLSPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IngressTLSPatchOutput) } +func (i IngressTLSPatchArgs) ToOutput(ctx context.Context) pulumix.Output[IngressTLSPatch] { + return pulumix.Output[IngressTLSPatch]{ + OutputState: i.ToIngressTLSPatchOutputWithContext(ctx).OutputState, + } +} + // IngressTLSPatchArrayInput is an input type that accepts IngressTLSPatchArray and IngressTLSPatchArrayOutput values. // You can construct a concrete instance of `IngressTLSPatchArrayInput` via: // @@ -3044,6 +3507,12 @@ func (i IngressTLSPatchArray) ToIngressTLSPatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(IngressTLSPatchArrayOutput) } +func (i IngressTLSPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLSPatch] { + return pulumix.Output[[]IngressTLSPatch]{ + OutputState: i.ToIngressTLSPatchArrayOutputWithContext(ctx).OutputState, + } +} + // IngressTLS describes the transport layer security associated with an Ingress. type IngressTLSPatchOutput struct{ *pulumi.OutputState } @@ -3059,6 +3528,12 @@ func (o IngressTLSPatchOutput) ToIngressTLSPatchOutputWithContext(ctx context.Co return o } +func (o IngressTLSPatchOutput) ToOutput(ctx context.Context) pulumix.Output[IngressTLSPatch] { + return pulumix.Output[IngressTLSPatch]{ + OutputState: o.OutputState, + } +} + // Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. func (o IngressTLSPatchOutput) Hosts() pulumi.StringArrayOutput { return o.ApplyT(func(v IngressTLSPatch) []string { return v.Hosts }).(pulumi.StringArrayOutput) @@ -3083,6 +3558,12 @@ func (o IngressTLSPatchArrayOutput) ToIngressTLSPatchArrayOutputWithContext(ctx return o } +func (o IngressTLSPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IngressTLSPatch] { + return pulumix.Output[[]IngressTLSPatch]{ + OutputState: o.OutputState, + } +} + func (o IngressTLSPatchArrayOutput) Index(i pulumi.IntInput) IngressTLSPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IngressTLSPatch { return vs[0].([]IngressTLSPatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/node/v1/pulumiTypes.go b/sdk/go/kubernetes/node/v1/pulumiTypes.go index adbccb1a6e..dc6306b178 100644 --- a/sdk/go/kubernetes/node/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/node/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -50,6 +51,12 @@ func (i OverheadArgs) ToOverheadOutputWithContext(ctx context.Context) OverheadO return pulumi.ToOutputWithContext(ctx, i).(OverheadOutput) } +func (i OverheadArgs) ToOutput(ctx context.Context) pulumix.Output[Overhead] { + return pulumix.Output[Overhead]{ + OutputState: i.ToOverheadOutputWithContext(ctx).OutputState, + } +} + func (i OverheadArgs) ToOverheadPtrOutput() OverheadPtrOutput { return i.ToOverheadPtrOutputWithContext(context.Background()) } @@ -91,6 +98,12 @@ func (i *overheadPtrType) ToOverheadPtrOutputWithContext(ctx context.Context) Ov return pulumi.ToOutputWithContext(ctx, i).(OverheadPtrOutput) } +func (i *overheadPtrType) ToOutput(ctx context.Context) pulumix.Output[*Overhead] { + return pulumix.Output[*Overhead]{ + OutputState: i.ToOverheadPtrOutputWithContext(ctx).OutputState, + } +} + // Overhead structure represents the resource overhead associated with running a pod. type OverheadOutput struct{ *pulumi.OutputState } @@ -116,6 +129,12 @@ func (o OverheadOutput) ToOverheadPtrOutputWithContext(ctx context.Context) Over }).(OverheadPtrOutput) } +func (o OverheadOutput) ToOutput(ctx context.Context) pulumix.Output[Overhead] { + return pulumix.Output[Overhead]{ + OutputState: o.OutputState, + } +} + // podFixed represents the fixed resource overhead associated with running a pod. func (o OverheadOutput) PodFixed() pulumi.StringMapOutput { return o.ApplyT(func(v Overhead) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput) @@ -135,6 +154,12 @@ func (o OverheadPtrOutput) ToOverheadPtrOutputWithContext(ctx context.Context) O return o } +func (o OverheadPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Overhead] { + return pulumix.Output[*Overhead]{ + OutputState: o.OutputState, + } +} + func (o OverheadPtrOutput) Elem() OverheadOutput { return o.ApplyT(func(v *Overhead) Overhead { if v != nil { @@ -190,6 +215,12 @@ func (i OverheadPatchArgs) ToOverheadPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchOutput) } +func (i OverheadPatchArgs) ToOutput(ctx context.Context) pulumix.Output[OverheadPatch] { + return pulumix.Output[OverheadPatch]{ + OutputState: i.ToOverheadPatchOutputWithContext(ctx).OutputState, + } +} + func (i OverheadPatchArgs) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput { return i.ToOverheadPatchPtrOutputWithContext(context.Background()) } @@ -231,6 +262,12 @@ func (i *overheadPatchPtrType) ToOverheadPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchPtrOutput) } +func (i *overheadPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*OverheadPatch] { + return pulumix.Output[*OverheadPatch]{ + OutputState: i.ToOverheadPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Overhead structure represents the resource overhead associated with running a pod. type OverheadPatchOutput struct{ *pulumi.OutputState } @@ -256,6 +293,12 @@ func (o OverheadPatchOutput) ToOverheadPatchPtrOutputWithContext(ctx context.Con }).(OverheadPatchPtrOutput) } +func (o OverheadPatchOutput) ToOutput(ctx context.Context) pulumix.Output[OverheadPatch] { + return pulumix.Output[OverheadPatch]{ + OutputState: o.OutputState, + } +} + // podFixed represents the fixed resource overhead associated with running a pod. func (o OverheadPatchOutput) PodFixed() pulumi.StringMapOutput { return o.ApplyT(func(v OverheadPatch) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput) @@ -275,6 +318,12 @@ func (o OverheadPatchPtrOutput) ToOverheadPatchPtrOutputWithContext(ctx context. return o } +func (o OverheadPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*OverheadPatch] { + return pulumix.Output[*OverheadPatch]{ + OutputState: o.OutputState, + } +} + func (o OverheadPatchPtrOutput) Elem() OverheadPatchOutput { return o.ApplyT(func(v *OverheadPatch) OverheadPatch { if v != nil { @@ -352,6 +401,12 @@ func (i RuntimeClassTypeArgs) ToRuntimeClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeOutput) } +func (i RuntimeClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassType] { + return pulumix.Output[RuntimeClassType]{ + OutputState: i.ToRuntimeClassTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassTypeArrayInput is an input type that accepts RuntimeClassTypeArray and RuntimeClassTypeArrayOutput values. // You can construct a concrete instance of `RuntimeClassTypeArrayInput` via: // @@ -377,6 +432,12 @@ func (i RuntimeClassTypeArray) ToRuntimeClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeArrayOutput) } +func (i RuntimeClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RuntimeClassType] { + return pulumix.Output[[]RuntimeClassType]{ + OutputState: i.ToRuntimeClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/ type RuntimeClassTypeOutput struct{ *pulumi.OutputState } @@ -392,6 +453,12 @@ func (o RuntimeClassTypeOutput) ToRuntimeClassTypeOutputWithContext(ctx context. return o } +func (o RuntimeClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassType] { + return pulumix.Output[RuntimeClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -438,6 +505,12 @@ func (o RuntimeClassTypeArrayOutput) ToRuntimeClassTypeArrayOutputWithContext(ct return o } +func (o RuntimeClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuntimeClassType] { + return pulumix.Output[[]RuntimeClassType]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassTypeArrayOutput) Index(i pulumi.IntInput) RuntimeClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuntimeClassType { return vs[0].([]RuntimeClassType)[vs[1].(int)] @@ -491,6 +564,12 @@ func (i RuntimeClassListTypeArgs) ToRuntimeClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListTypeOutput) } +func (i RuntimeClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassListType] { + return pulumix.Output[RuntimeClassListType]{ + OutputState: i.ToRuntimeClassListTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassList is a list of RuntimeClass objects. type RuntimeClassListTypeOutput struct{ *pulumi.OutputState } @@ -506,6 +585,12 @@ func (o RuntimeClassListTypeOutput) ToRuntimeClassListTypeOutputWithContext(ctx return o } +func (o RuntimeClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassListType] { + return pulumix.Output[RuntimeClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -583,6 +668,12 @@ func (i RuntimeClassPatchTypeArgs) ToRuntimeClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchTypeOutput) } +func (i RuntimeClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassPatchType] { + return pulumix.Output[RuntimeClassPatchType]{ + OutputState: i.ToRuntimeClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/ type RuntimeClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -598,6 +689,12 @@ func (o RuntimeClassPatchTypeOutput) ToRuntimeClassPatchTypeOutputWithContext(ct return o } +func (o RuntimeClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassPatchType] { + return pulumix.Output[RuntimeClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -669,6 +766,12 @@ func (i SchedulingArgs) ToSchedulingOutputWithContext(ctx context.Context) Sched return pulumi.ToOutputWithContext(ctx, i).(SchedulingOutput) } +func (i SchedulingArgs) ToOutput(ctx context.Context) pulumix.Output[Scheduling] { + return pulumix.Output[Scheduling]{ + OutputState: i.ToSchedulingOutputWithContext(ctx).OutputState, + } +} + func (i SchedulingArgs) ToSchedulingPtrOutput() SchedulingPtrOutput { return i.ToSchedulingPtrOutputWithContext(context.Background()) } @@ -710,6 +813,12 @@ func (i *schedulingPtrType) ToSchedulingPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(SchedulingPtrOutput) } +func (i *schedulingPtrType) ToOutput(ctx context.Context) pulumix.Output[*Scheduling] { + return pulumix.Output[*Scheduling]{ + OutputState: i.ToSchedulingPtrOutputWithContext(ctx).OutputState, + } +} + // Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. type SchedulingOutput struct{ *pulumi.OutputState } @@ -735,6 +844,12 @@ func (o SchedulingOutput) ToSchedulingPtrOutputWithContext(ctx context.Context) }).(SchedulingPtrOutput) } +func (o SchedulingOutput) ToOutput(ctx context.Context) pulumix.Output[Scheduling] { + return pulumix.Output[Scheduling]{ + OutputState: o.OutputState, + } +} + // nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. func (o SchedulingOutput) NodeSelector() pulumi.StringMapOutput { return o.ApplyT(func(v Scheduling) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput) @@ -759,6 +874,12 @@ func (o SchedulingPtrOutput) ToSchedulingPtrOutputWithContext(ctx context.Contex return o } +func (o SchedulingPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Scheduling] { + return pulumix.Output[*Scheduling]{ + OutputState: o.OutputState, + } +} + func (o SchedulingPtrOutput) Elem() SchedulingOutput { return o.ApplyT(func(v *Scheduling) Scheduling { if v != nil { @@ -828,6 +949,12 @@ func (i SchedulingPatchArgs) ToSchedulingPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchOutput) } +func (i SchedulingPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SchedulingPatch] { + return pulumix.Output[SchedulingPatch]{ + OutputState: i.ToSchedulingPatchOutputWithContext(ctx).OutputState, + } +} + func (i SchedulingPatchArgs) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput { return i.ToSchedulingPatchPtrOutputWithContext(context.Background()) } @@ -869,6 +996,12 @@ func (i *schedulingPatchPtrType) ToSchedulingPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchPtrOutput) } +func (i *schedulingPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SchedulingPatch] { + return pulumix.Output[*SchedulingPatch]{ + OutputState: i.ToSchedulingPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. type SchedulingPatchOutput struct{ *pulumi.OutputState } @@ -894,6 +1027,12 @@ func (o SchedulingPatchOutput) ToSchedulingPatchPtrOutputWithContext(ctx context }).(SchedulingPatchPtrOutput) } +func (o SchedulingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SchedulingPatch] { + return pulumix.Output[SchedulingPatch]{ + OutputState: o.OutputState, + } +} + // nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. func (o SchedulingPatchOutput) NodeSelector() pulumi.StringMapOutput { return o.ApplyT(func(v SchedulingPatch) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput) @@ -918,6 +1057,12 @@ func (o SchedulingPatchPtrOutput) ToSchedulingPatchPtrOutputWithContext(ctx cont return o } +func (o SchedulingPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SchedulingPatch] { + return pulumix.Output[*SchedulingPatch]{ + OutputState: o.OutputState, + } +} + func (o SchedulingPatchPtrOutput) Elem() SchedulingPatchOutput { return o.ApplyT(func(v *SchedulingPatch) SchedulingPatch { if v != nil { diff --git a/sdk/go/kubernetes/node/v1/runtimeClass.go b/sdk/go/kubernetes/node/v1/runtimeClass.go index 7208a54b11..c8c9318cd9 100644 --- a/sdk/go/kubernetes/node/v1/runtimeClass.go +++ b/sdk/go/kubernetes/node/v1/runtimeClass.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/ @@ -141,6 +142,12 @@ func (i *RuntimeClass) ToRuntimeClassOutputWithContext(ctx context.Context) Runt return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassOutput) } +func (i *RuntimeClass) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClass] { + return pulumix.Output[*RuntimeClass]{ + OutputState: i.ToRuntimeClassOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassArrayInput is an input type that accepts RuntimeClassArray and RuntimeClassArrayOutput values. // You can construct a concrete instance of `RuntimeClassArrayInput` via: // @@ -166,6 +173,12 @@ func (i RuntimeClassArray) ToRuntimeClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassArrayOutput) } +func (i RuntimeClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClass] { + return pulumix.Output[[]*RuntimeClass]{ + OutputState: i.ToRuntimeClassArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassMapInput is an input type that accepts RuntimeClassMap and RuntimeClassMapOutput values. // You can construct a concrete instance of `RuntimeClassMapInput` via: // @@ -191,6 +204,12 @@ func (i RuntimeClassMap) ToRuntimeClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassMapOutput) } +func (i RuntimeClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClass] { + return pulumix.Output[map[string]*RuntimeClass]{ + OutputState: i.ToRuntimeClassMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassOutput struct{ *pulumi.OutputState } func (RuntimeClassOutput) ElementType() reflect.Type { @@ -205,6 +224,12 @@ func (o RuntimeClassOutput) ToRuntimeClassOutputWithContext(ctx context.Context) return o } +func (o RuntimeClassOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClass] { + return pulumix.Output[*RuntimeClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RuntimeClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -251,6 +276,12 @@ func (o RuntimeClassArrayOutput) ToRuntimeClassArrayOutputWithContext(ctx contex return o } +func (o RuntimeClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClass] { + return pulumix.Output[[]*RuntimeClass]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassArrayOutput) Index(i pulumi.IntInput) RuntimeClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClass { return vs[0].([]*RuntimeClass)[vs[1].(int)] @@ -271,6 +302,12 @@ func (o RuntimeClassMapOutput) ToRuntimeClassMapOutputWithContext(ctx context.Co return o } +func (o RuntimeClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClass] { + return pulumix.Output[map[string]*RuntimeClass]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClass { return vs[0].(map[string]*RuntimeClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1/runtimeClassList.go b/sdk/go/kubernetes/node/v1/runtimeClassList.go index 2c2e8ef537..fecbfe090e 100644 --- a/sdk/go/kubernetes/node/v1/runtimeClassList.go +++ b/sdk/go/kubernetes/node/v1/runtimeClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RuntimeClassList is a list of RuntimeClass objects. @@ -117,6 +118,12 @@ func (i *RuntimeClassList) ToRuntimeClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListOutput) } +func (i *RuntimeClassList) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassList] { + return pulumix.Output[*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassListArrayInput is an input type that accepts RuntimeClassListArray and RuntimeClassListArrayOutput values. // You can construct a concrete instance of `RuntimeClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RuntimeClassListArray) ToRuntimeClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListArrayOutput) } +func (i RuntimeClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassList] { + return pulumix.Output[[]*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassListMapInput is an input type that accepts RuntimeClassListMap and RuntimeClassListMapOutput values. // You can construct a concrete instance of `RuntimeClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i RuntimeClassListMap) ToRuntimeClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListMapOutput) } +func (i RuntimeClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassList] { + return pulumix.Output[map[string]*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassListOutput struct{ *pulumi.OutputState } func (RuntimeClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RuntimeClassListOutput) ToRuntimeClassListOutputWithContext(ctx context. return o } +func (o RuntimeClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassList] { + return pulumix.Output[*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RuntimeClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RuntimeClassListArrayOutput) ToRuntimeClassListArrayOutputWithContext(ct return o } +func (o RuntimeClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassList] { + return pulumix.Output[[]*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassListArrayOutput) Index(i pulumi.IntInput) RuntimeClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClassList { return vs[0].([]*RuntimeClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RuntimeClassListMapOutput) ToRuntimeClassListMapOutputWithContext(ctx co return o } +func (o RuntimeClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassList] { + return pulumix.Output[map[string]*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassListMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClassList { return vs[0].(map[string]*RuntimeClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1/runtimeClassPatch.go b/sdk/go/kubernetes/node/v1/runtimeClassPatch.go index 0eb7cf1e8b..05aef89607 100644 --- a/sdk/go/kubernetes/node/v1/runtimeClassPatch.go +++ b/sdk/go/kubernetes/node/v1/runtimeClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -143,6 +144,12 @@ func (i *RuntimeClassPatch) ToRuntimeClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchOutput) } +func (i *RuntimeClassPatch) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassPatch] { + return pulumix.Output[*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassPatchArrayInput is an input type that accepts RuntimeClassPatchArray and RuntimeClassPatchArrayOutput values. // You can construct a concrete instance of `RuntimeClassPatchArrayInput` via: // @@ -168,6 +175,12 @@ func (i RuntimeClassPatchArray) ToRuntimeClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchArrayOutput) } +func (i RuntimeClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassPatch] { + return pulumix.Output[[]*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassPatchMapInput is an input type that accepts RuntimeClassPatchMap and RuntimeClassPatchMapOutput values. // You can construct a concrete instance of `RuntimeClassPatchMapInput` via: // @@ -193,6 +206,12 @@ func (i RuntimeClassPatchMap) ToRuntimeClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchMapOutput) } +func (i RuntimeClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassPatch] { + return pulumix.Output[map[string]*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassPatchOutput struct{ *pulumi.OutputState } func (RuntimeClassPatchOutput) ElementType() reflect.Type { @@ -207,6 +226,12 @@ func (o RuntimeClassPatchOutput) ToRuntimeClassPatchOutputWithContext(ctx contex return o } +func (o RuntimeClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassPatch] { + return pulumix.Output[*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RuntimeClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -253,6 +278,12 @@ func (o RuntimeClassPatchArrayOutput) ToRuntimeClassPatchArrayOutputWithContext( return o } +func (o RuntimeClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassPatch] { + return pulumix.Output[[]*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassPatchArrayOutput) Index(i pulumi.IntInput) RuntimeClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClassPatch { return vs[0].([]*RuntimeClassPatch)[vs[1].(int)] @@ -273,6 +304,12 @@ func (o RuntimeClassPatchMapOutput) ToRuntimeClassPatchMapOutputWithContext(ctx return o } +func (o RuntimeClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassPatch] { + return pulumix.Output[map[string]*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassPatchMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClassPatch { return vs[0].(map[string]*RuntimeClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/node/v1alpha1/pulumiTypes.go index 75671d334d..43987cb88c 100644 --- a/sdk/go/kubernetes/node/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/node/v1alpha1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -50,6 +51,12 @@ func (i OverheadArgs) ToOverheadOutputWithContext(ctx context.Context) OverheadO return pulumi.ToOutputWithContext(ctx, i).(OverheadOutput) } +func (i OverheadArgs) ToOutput(ctx context.Context) pulumix.Output[Overhead] { + return pulumix.Output[Overhead]{ + OutputState: i.ToOverheadOutputWithContext(ctx).OutputState, + } +} + func (i OverheadArgs) ToOverheadPtrOutput() OverheadPtrOutput { return i.ToOverheadPtrOutputWithContext(context.Background()) } @@ -91,6 +98,12 @@ func (i *overheadPtrType) ToOverheadPtrOutputWithContext(ctx context.Context) Ov return pulumi.ToOutputWithContext(ctx, i).(OverheadPtrOutput) } +func (i *overheadPtrType) ToOutput(ctx context.Context) pulumix.Output[*Overhead] { + return pulumix.Output[*Overhead]{ + OutputState: i.ToOverheadPtrOutputWithContext(ctx).OutputState, + } +} + // Overhead structure represents the resource overhead associated with running a pod. type OverheadOutput struct{ *pulumi.OutputState } @@ -116,6 +129,12 @@ func (o OverheadOutput) ToOverheadPtrOutputWithContext(ctx context.Context) Over }).(OverheadPtrOutput) } +func (o OverheadOutput) ToOutput(ctx context.Context) pulumix.Output[Overhead] { + return pulumix.Output[Overhead]{ + OutputState: o.OutputState, + } +} + // PodFixed represents the fixed resource overhead associated with running a pod. func (o OverheadOutput) PodFixed() pulumi.StringMapOutput { return o.ApplyT(func(v Overhead) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput) @@ -135,6 +154,12 @@ func (o OverheadPtrOutput) ToOverheadPtrOutputWithContext(ctx context.Context) O return o } +func (o OverheadPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Overhead] { + return pulumix.Output[*Overhead]{ + OutputState: o.OutputState, + } +} + func (o OverheadPtrOutput) Elem() OverheadOutput { return o.ApplyT(func(v *Overhead) Overhead { if v != nil { @@ -190,6 +215,12 @@ func (i OverheadPatchArgs) ToOverheadPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchOutput) } +func (i OverheadPatchArgs) ToOutput(ctx context.Context) pulumix.Output[OverheadPatch] { + return pulumix.Output[OverheadPatch]{ + OutputState: i.ToOverheadPatchOutputWithContext(ctx).OutputState, + } +} + func (i OverheadPatchArgs) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput { return i.ToOverheadPatchPtrOutputWithContext(context.Background()) } @@ -231,6 +262,12 @@ func (i *overheadPatchPtrType) ToOverheadPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchPtrOutput) } +func (i *overheadPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*OverheadPatch] { + return pulumix.Output[*OverheadPatch]{ + OutputState: i.ToOverheadPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Overhead structure represents the resource overhead associated with running a pod. type OverheadPatchOutput struct{ *pulumi.OutputState } @@ -256,6 +293,12 @@ func (o OverheadPatchOutput) ToOverheadPatchPtrOutputWithContext(ctx context.Con }).(OverheadPatchPtrOutput) } +func (o OverheadPatchOutput) ToOutput(ctx context.Context) pulumix.Output[OverheadPatch] { + return pulumix.Output[OverheadPatch]{ + OutputState: o.OutputState, + } +} + // PodFixed represents the fixed resource overhead associated with running a pod. func (o OverheadPatchOutput) PodFixed() pulumi.StringMapOutput { return o.ApplyT(func(v OverheadPatch) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput) @@ -275,6 +318,12 @@ func (o OverheadPatchPtrOutput) ToOverheadPatchPtrOutputWithContext(ctx context. return o } +func (o OverheadPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*OverheadPatch] { + return pulumix.Output[*OverheadPatch]{ + OutputState: o.OutputState, + } +} + func (o OverheadPatchPtrOutput) Elem() OverheadPatchOutput { return o.ApplyT(func(v *OverheadPatch) OverheadPatch { if v != nil { @@ -342,6 +391,12 @@ func (i RuntimeClassTypeArgs) ToRuntimeClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeOutput) } +func (i RuntimeClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassType] { + return pulumix.Output[RuntimeClassType]{ + OutputState: i.ToRuntimeClassTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassTypeArrayInput is an input type that accepts RuntimeClassTypeArray and RuntimeClassTypeArrayOutput values. // You can construct a concrete instance of `RuntimeClassTypeArrayInput` via: // @@ -367,6 +422,12 @@ func (i RuntimeClassTypeArray) ToRuntimeClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeArrayOutput) } +func (i RuntimeClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RuntimeClassType] { + return pulumix.Output[[]RuntimeClassType]{ + OutputState: i.ToRuntimeClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md type RuntimeClassTypeOutput struct{ *pulumi.OutputState } @@ -382,6 +443,12 @@ func (o RuntimeClassTypeOutput) ToRuntimeClassTypeOutputWithContext(ctx context. return o } +func (o RuntimeClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassType] { + return pulumix.Output[RuntimeClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -416,6 +483,12 @@ func (o RuntimeClassTypeArrayOutput) ToRuntimeClassTypeArrayOutputWithContext(ct return o } +func (o RuntimeClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuntimeClassType] { + return pulumix.Output[[]RuntimeClassType]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassTypeArrayOutput) Index(i pulumi.IntInput) RuntimeClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuntimeClassType { return vs[0].([]RuntimeClassType)[vs[1].(int)] @@ -469,6 +542,12 @@ func (i RuntimeClassListTypeArgs) ToRuntimeClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListTypeOutput) } +func (i RuntimeClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassListType] { + return pulumix.Output[RuntimeClassListType]{ + OutputState: i.ToRuntimeClassListTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassList is a list of RuntimeClass objects. type RuntimeClassListTypeOutput struct{ *pulumi.OutputState } @@ -484,6 +563,12 @@ func (o RuntimeClassListTypeOutput) ToRuntimeClassListTypeOutputWithContext(ctx return o } +func (o RuntimeClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassListType] { + return pulumix.Output[RuntimeClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -551,6 +636,12 @@ func (i RuntimeClassPatchTypeArgs) ToRuntimeClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchTypeOutput) } +func (i RuntimeClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassPatchType] { + return pulumix.Output[RuntimeClassPatchType]{ + OutputState: i.ToRuntimeClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md type RuntimeClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -566,6 +657,12 @@ func (o RuntimeClassPatchTypeOutput) ToRuntimeClassPatchTypeOutputWithContext(ct return o } +func (o RuntimeClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassPatchType] { + return pulumix.Output[RuntimeClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -629,6 +726,12 @@ func (i RuntimeClassSpecArgs) ToRuntimeClassSpecOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassSpecOutput) } +func (i RuntimeClassSpecArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassSpec] { + return pulumix.Output[RuntimeClassSpec]{ + OutputState: i.ToRuntimeClassSpecOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassSpec is a specification of a RuntimeClass. It contains parameters that are required to describe the RuntimeClass to the Container Runtime Interface (CRI) implementation, as well as any other components that need to understand how the pod will be run. The RuntimeClassSpec is immutable. type RuntimeClassSpecOutput struct{ *pulumi.OutputState } @@ -644,6 +747,12 @@ func (o RuntimeClassSpecOutput) ToRuntimeClassSpecOutputWithContext(ctx context. return o } +func (o RuntimeClassSpecOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassSpec] { + return pulumix.Output[RuntimeClassSpec]{ + OutputState: o.OutputState, + } +} + // Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see https://git.k8s.io/enhancements/keps/sig-node/20190226-pod-overhead.md This field is alpha-level as of Kubernetes v1.15, and is only honored by servers that enable the PodOverhead feature. func (o RuntimeClassSpecOutput) Overhead() OverheadPtrOutput { return o.ApplyT(func(v RuntimeClassSpec) *Overhead { return v.Overhead }).(OverheadPtrOutput) @@ -702,6 +811,12 @@ func (i RuntimeClassSpecPatchArgs) ToRuntimeClassSpecPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassSpecPatchOutput) } +func (i RuntimeClassSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassSpecPatch] { + return pulumix.Output[RuntimeClassSpecPatch]{ + OutputState: i.ToRuntimeClassSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i RuntimeClassSpecPatchArgs) ToRuntimeClassSpecPatchPtrOutput() RuntimeClassSpecPatchPtrOutput { return i.ToRuntimeClassSpecPatchPtrOutputWithContext(context.Background()) } @@ -743,6 +858,12 @@ func (i *runtimeClassSpecPatchPtrType) ToRuntimeClassSpecPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassSpecPatchPtrOutput) } +func (i *runtimeClassSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassSpecPatch] { + return pulumix.Output[*RuntimeClassSpecPatch]{ + OutputState: i.ToRuntimeClassSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassSpec is a specification of a RuntimeClass. It contains parameters that are required to describe the RuntimeClass to the Container Runtime Interface (CRI) implementation, as well as any other components that need to understand how the pod will be run. The RuntimeClassSpec is immutable. type RuntimeClassSpecPatchOutput struct{ *pulumi.OutputState } @@ -768,6 +889,12 @@ func (o RuntimeClassSpecPatchOutput) ToRuntimeClassSpecPatchPtrOutputWithContext }).(RuntimeClassSpecPatchPtrOutput) } +func (o RuntimeClassSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassSpecPatch] { + return pulumix.Output[RuntimeClassSpecPatch]{ + OutputState: o.OutputState, + } +} + // Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see https://git.k8s.io/enhancements/keps/sig-node/20190226-pod-overhead.md This field is alpha-level as of Kubernetes v1.15, and is only honored by servers that enable the PodOverhead feature. func (o RuntimeClassSpecPatchOutput) Overhead() OverheadPatchPtrOutput { return o.ApplyT(func(v RuntimeClassSpecPatch) *OverheadPatch { return v.Overhead }).(OverheadPatchPtrOutput) @@ -797,6 +924,12 @@ func (o RuntimeClassSpecPatchPtrOutput) ToRuntimeClassSpecPatchPtrOutputWithCont return o } +func (o RuntimeClassSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassSpecPatch] { + return pulumix.Output[*RuntimeClassSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassSpecPatchPtrOutput) Elem() RuntimeClassSpecPatchOutput { return o.ApplyT(func(v *RuntimeClassSpecPatch) RuntimeClassSpecPatch { if v != nil { @@ -876,6 +1009,12 @@ func (i SchedulingArgs) ToSchedulingOutputWithContext(ctx context.Context) Sched return pulumi.ToOutputWithContext(ctx, i).(SchedulingOutput) } +func (i SchedulingArgs) ToOutput(ctx context.Context) pulumix.Output[Scheduling] { + return pulumix.Output[Scheduling]{ + OutputState: i.ToSchedulingOutputWithContext(ctx).OutputState, + } +} + func (i SchedulingArgs) ToSchedulingPtrOutput() SchedulingPtrOutput { return i.ToSchedulingPtrOutputWithContext(context.Background()) } @@ -917,6 +1056,12 @@ func (i *schedulingPtrType) ToSchedulingPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(SchedulingPtrOutput) } +func (i *schedulingPtrType) ToOutput(ctx context.Context) pulumix.Output[*Scheduling] { + return pulumix.Output[*Scheduling]{ + OutputState: i.ToSchedulingPtrOutputWithContext(ctx).OutputState, + } +} + // Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. type SchedulingOutput struct{ *pulumi.OutputState } @@ -942,6 +1087,12 @@ func (o SchedulingOutput) ToSchedulingPtrOutputWithContext(ctx context.Context) }).(SchedulingPtrOutput) } +func (o SchedulingOutput) ToOutput(ctx context.Context) pulumix.Output[Scheduling] { + return pulumix.Output[Scheduling]{ + OutputState: o.OutputState, + } +} + // nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. func (o SchedulingOutput) NodeSelector() pulumi.StringMapOutput { return o.ApplyT(func(v Scheduling) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput) @@ -966,6 +1117,12 @@ func (o SchedulingPtrOutput) ToSchedulingPtrOutputWithContext(ctx context.Contex return o } +func (o SchedulingPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Scheduling] { + return pulumix.Output[*Scheduling]{ + OutputState: o.OutputState, + } +} + func (o SchedulingPtrOutput) Elem() SchedulingOutput { return o.ApplyT(func(v *Scheduling) Scheduling { if v != nil { @@ -1035,6 +1192,12 @@ func (i SchedulingPatchArgs) ToSchedulingPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchOutput) } +func (i SchedulingPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SchedulingPatch] { + return pulumix.Output[SchedulingPatch]{ + OutputState: i.ToSchedulingPatchOutputWithContext(ctx).OutputState, + } +} + func (i SchedulingPatchArgs) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput { return i.ToSchedulingPatchPtrOutputWithContext(context.Background()) } @@ -1076,6 +1239,12 @@ func (i *schedulingPatchPtrType) ToSchedulingPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchPtrOutput) } +func (i *schedulingPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SchedulingPatch] { + return pulumix.Output[*SchedulingPatch]{ + OutputState: i.ToSchedulingPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. type SchedulingPatchOutput struct{ *pulumi.OutputState } @@ -1101,6 +1270,12 @@ func (o SchedulingPatchOutput) ToSchedulingPatchPtrOutputWithContext(ctx context }).(SchedulingPatchPtrOutput) } +func (o SchedulingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SchedulingPatch] { + return pulumix.Output[SchedulingPatch]{ + OutputState: o.OutputState, + } +} + // nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. func (o SchedulingPatchOutput) NodeSelector() pulumi.StringMapOutput { return o.ApplyT(func(v SchedulingPatch) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput) @@ -1125,6 +1300,12 @@ func (o SchedulingPatchPtrOutput) ToSchedulingPatchPtrOutputWithContext(ctx cont return o } +func (o SchedulingPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SchedulingPatch] { + return pulumix.Output[*SchedulingPatch]{ + OutputState: o.OutputState, + } +} + func (o SchedulingPatchPtrOutput) Elem() SchedulingPatchOutput { return o.ApplyT(func(v *SchedulingPatch) SchedulingPatch { if v != nil { diff --git a/sdk/go/kubernetes/node/v1alpha1/runtimeClass.go b/sdk/go/kubernetes/node/v1alpha1/runtimeClass.go index 2beee14760..435d789ada 100644 --- a/sdk/go/kubernetes/node/v1alpha1/runtimeClass.go +++ b/sdk/go/kubernetes/node/v1alpha1/runtimeClass.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md @@ -126,6 +127,12 @@ func (i *RuntimeClass) ToRuntimeClassOutputWithContext(ctx context.Context) Runt return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassOutput) } +func (i *RuntimeClass) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClass] { + return pulumix.Output[*RuntimeClass]{ + OutputState: i.ToRuntimeClassOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassArrayInput is an input type that accepts RuntimeClassArray and RuntimeClassArrayOutput values. // You can construct a concrete instance of `RuntimeClassArrayInput` via: // @@ -151,6 +158,12 @@ func (i RuntimeClassArray) ToRuntimeClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassArrayOutput) } +func (i RuntimeClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClass] { + return pulumix.Output[[]*RuntimeClass]{ + OutputState: i.ToRuntimeClassArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassMapInput is an input type that accepts RuntimeClassMap and RuntimeClassMapOutput values. // You can construct a concrete instance of `RuntimeClassMapInput` via: // @@ -176,6 +189,12 @@ func (i RuntimeClassMap) ToRuntimeClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassMapOutput) } +func (i RuntimeClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClass] { + return pulumix.Output[map[string]*RuntimeClass]{ + OutputState: i.ToRuntimeClassMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassOutput struct{ *pulumi.OutputState } func (RuntimeClassOutput) ElementType() reflect.Type { @@ -190,6 +209,12 @@ func (o RuntimeClassOutput) ToRuntimeClassOutputWithContext(ctx context.Context) return o } +func (o RuntimeClassOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClass] { + return pulumix.Output[*RuntimeClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RuntimeClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o RuntimeClassArrayOutput) ToRuntimeClassArrayOutputWithContext(ctx contex return o } +func (o RuntimeClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClass] { + return pulumix.Output[[]*RuntimeClass]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassArrayOutput) Index(i pulumi.IntInput) RuntimeClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClass { return vs[0].([]*RuntimeClass)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o RuntimeClassMapOutput) ToRuntimeClassMapOutputWithContext(ctx context.Co return o } +func (o RuntimeClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClass] { + return pulumix.Output[map[string]*RuntimeClass]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClass { return vs[0].(map[string]*RuntimeClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1alpha1/runtimeClassList.go b/sdk/go/kubernetes/node/v1alpha1/runtimeClassList.go index 0a5c555e58..16b1a74863 100644 --- a/sdk/go/kubernetes/node/v1alpha1/runtimeClassList.go +++ b/sdk/go/kubernetes/node/v1alpha1/runtimeClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RuntimeClassList is a list of RuntimeClass objects. @@ -117,6 +118,12 @@ func (i *RuntimeClassList) ToRuntimeClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListOutput) } +func (i *RuntimeClassList) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassList] { + return pulumix.Output[*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassListArrayInput is an input type that accepts RuntimeClassListArray and RuntimeClassListArrayOutput values. // You can construct a concrete instance of `RuntimeClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RuntimeClassListArray) ToRuntimeClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListArrayOutput) } +func (i RuntimeClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassList] { + return pulumix.Output[[]*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassListMapInput is an input type that accepts RuntimeClassListMap and RuntimeClassListMapOutput values. // You can construct a concrete instance of `RuntimeClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i RuntimeClassListMap) ToRuntimeClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListMapOutput) } +func (i RuntimeClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassList] { + return pulumix.Output[map[string]*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassListOutput struct{ *pulumi.OutputState } func (RuntimeClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RuntimeClassListOutput) ToRuntimeClassListOutputWithContext(ctx context. return o } +func (o RuntimeClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassList] { + return pulumix.Output[*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RuntimeClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RuntimeClassListArrayOutput) ToRuntimeClassListArrayOutputWithContext(ct return o } +func (o RuntimeClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassList] { + return pulumix.Output[[]*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassListArrayOutput) Index(i pulumi.IntInput) RuntimeClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClassList { return vs[0].([]*RuntimeClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RuntimeClassListMapOutput) ToRuntimeClassListMapOutputWithContext(ctx co return o } +func (o RuntimeClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassList] { + return pulumix.Output[map[string]*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassListMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClassList { return vs[0].(map[string]*RuntimeClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1alpha1/runtimeClassPatch.go b/sdk/go/kubernetes/node/v1alpha1/runtimeClassPatch.go index 7dd5f1e5ca..60e1035600 100644 --- a/sdk/go/kubernetes/node/v1alpha1/runtimeClassPatch.go +++ b/sdk/go/kubernetes/node/v1alpha1/runtimeClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -128,6 +129,12 @@ func (i *RuntimeClassPatch) ToRuntimeClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchOutput) } +func (i *RuntimeClassPatch) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassPatch] { + return pulumix.Output[*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassPatchArrayInput is an input type that accepts RuntimeClassPatchArray and RuntimeClassPatchArrayOutput values. // You can construct a concrete instance of `RuntimeClassPatchArrayInput` via: // @@ -153,6 +160,12 @@ func (i RuntimeClassPatchArray) ToRuntimeClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchArrayOutput) } +func (i RuntimeClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassPatch] { + return pulumix.Output[[]*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassPatchMapInput is an input type that accepts RuntimeClassPatchMap and RuntimeClassPatchMapOutput values. // You can construct a concrete instance of `RuntimeClassPatchMapInput` via: // @@ -178,6 +191,12 @@ func (i RuntimeClassPatchMap) ToRuntimeClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchMapOutput) } +func (i RuntimeClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassPatch] { + return pulumix.Output[map[string]*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassPatchOutput struct{ *pulumi.OutputState } func (RuntimeClassPatchOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o RuntimeClassPatchOutput) ToRuntimeClassPatchOutputWithContext(ctx contex return o } +func (o RuntimeClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassPatch] { + return pulumix.Output[*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RuntimeClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o RuntimeClassPatchArrayOutput) ToRuntimeClassPatchArrayOutputWithContext( return o } +func (o RuntimeClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassPatch] { + return pulumix.Output[[]*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassPatchArrayOutput) Index(i pulumi.IntInput) RuntimeClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClassPatch { return vs[0].([]*RuntimeClassPatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o RuntimeClassPatchMapOutput) ToRuntimeClassPatchMapOutputWithContext(ctx return o } +func (o RuntimeClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassPatch] { + return pulumix.Output[map[string]*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassPatchMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClassPatch { return vs[0].(map[string]*RuntimeClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/node/v1beta1/pulumiTypes.go index a1d28495ae..fa9af323cd 100644 --- a/sdk/go/kubernetes/node/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/node/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -50,6 +51,12 @@ func (i OverheadArgs) ToOverheadOutputWithContext(ctx context.Context) OverheadO return pulumi.ToOutputWithContext(ctx, i).(OverheadOutput) } +func (i OverheadArgs) ToOutput(ctx context.Context) pulumix.Output[Overhead] { + return pulumix.Output[Overhead]{ + OutputState: i.ToOverheadOutputWithContext(ctx).OutputState, + } +} + func (i OverheadArgs) ToOverheadPtrOutput() OverheadPtrOutput { return i.ToOverheadPtrOutputWithContext(context.Background()) } @@ -91,6 +98,12 @@ func (i *overheadPtrType) ToOverheadPtrOutputWithContext(ctx context.Context) Ov return pulumi.ToOutputWithContext(ctx, i).(OverheadPtrOutput) } +func (i *overheadPtrType) ToOutput(ctx context.Context) pulumix.Output[*Overhead] { + return pulumix.Output[*Overhead]{ + OutputState: i.ToOverheadPtrOutputWithContext(ctx).OutputState, + } +} + // Overhead structure represents the resource overhead associated with running a pod. type OverheadOutput struct{ *pulumi.OutputState } @@ -116,6 +129,12 @@ func (o OverheadOutput) ToOverheadPtrOutputWithContext(ctx context.Context) Over }).(OverheadPtrOutput) } +func (o OverheadOutput) ToOutput(ctx context.Context) pulumix.Output[Overhead] { + return pulumix.Output[Overhead]{ + OutputState: o.OutputState, + } +} + // PodFixed represents the fixed resource overhead associated with running a pod. func (o OverheadOutput) PodFixed() pulumi.StringMapOutput { return o.ApplyT(func(v Overhead) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput) @@ -135,6 +154,12 @@ func (o OverheadPtrOutput) ToOverheadPtrOutputWithContext(ctx context.Context) O return o } +func (o OverheadPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Overhead] { + return pulumix.Output[*Overhead]{ + OutputState: o.OutputState, + } +} + func (o OverheadPtrOutput) Elem() OverheadOutput { return o.ApplyT(func(v *Overhead) Overhead { if v != nil { @@ -190,6 +215,12 @@ func (i OverheadPatchArgs) ToOverheadPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchOutput) } +func (i OverheadPatchArgs) ToOutput(ctx context.Context) pulumix.Output[OverheadPatch] { + return pulumix.Output[OverheadPatch]{ + OutputState: i.ToOverheadPatchOutputWithContext(ctx).OutputState, + } +} + func (i OverheadPatchArgs) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput { return i.ToOverheadPatchPtrOutputWithContext(context.Background()) } @@ -231,6 +262,12 @@ func (i *overheadPatchPtrType) ToOverheadPatchPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchPtrOutput) } +func (i *overheadPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*OverheadPatch] { + return pulumix.Output[*OverheadPatch]{ + OutputState: i.ToOverheadPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Overhead structure represents the resource overhead associated with running a pod. type OverheadPatchOutput struct{ *pulumi.OutputState } @@ -256,6 +293,12 @@ func (o OverheadPatchOutput) ToOverheadPatchPtrOutputWithContext(ctx context.Con }).(OverheadPatchPtrOutput) } +func (o OverheadPatchOutput) ToOutput(ctx context.Context) pulumix.Output[OverheadPatch] { + return pulumix.Output[OverheadPatch]{ + OutputState: o.OutputState, + } +} + // PodFixed represents the fixed resource overhead associated with running a pod. func (o OverheadPatchOutput) PodFixed() pulumi.StringMapOutput { return o.ApplyT(func(v OverheadPatch) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput) @@ -275,6 +318,12 @@ func (o OverheadPatchPtrOutput) ToOverheadPatchPtrOutputWithContext(ctx context. return o } +func (o OverheadPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*OverheadPatch] { + return pulumix.Output[*OverheadPatch]{ + OutputState: o.OutputState, + } +} + func (o OverheadPatchPtrOutput) Elem() OverheadPatchOutput { return o.ApplyT(func(v *OverheadPatch) OverheadPatch { if v != nil { @@ -350,6 +399,12 @@ func (i RuntimeClassTypeArgs) ToRuntimeClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeOutput) } +func (i RuntimeClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassType] { + return pulumix.Output[RuntimeClassType]{ + OutputState: i.ToRuntimeClassTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassTypeArrayInput is an input type that accepts RuntimeClassTypeArray and RuntimeClassTypeArrayOutput values. // You can construct a concrete instance of `RuntimeClassTypeArrayInput` via: // @@ -375,6 +430,12 @@ func (i RuntimeClassTypeArray) ToRuntimeClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeArrayOutput) } +func (i RuntimeClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RuntimeClassType] { + return pulumix.Output[[]RuntimeClassType]{ + OutputState: i.ToRuntimeClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md type RuntimeClassTypeOutput struct{ *pulumi.OutputState } @@ -390,6 +451,12 @@ func (o RuntimeClassTypeOutput) ToRuntimeClassTypeOutputWithContext(ctx context. return o } +func (o RuntimeClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassType] { + return pulumix.Output[RuntimeClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -434,6 +501,12 @@ func (o RuntimeClassTypeArrayOutput) ToRuntimeClassTypeArrayOutputWithContext(ct return o } +func (o RuntimeClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RuntimeClassType] { + return pulumix.Output[[]RuntimeClassType]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassTypeArrayOutput) Index(i pulumi.IntInput) RuntimeClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuntimeClassType { return vs[0].([]RuntimeClassType)[vs[1].(int)] @@ -487,6 +560,12 @@ func (i RuntimeClassListTypeArgs) ToRuntimeClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListTypeOutput) } +func (i RuntimeClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassListType] { + return pulumix.Output[RuntimeClassListType]{ + OutputState: i.ToRuntimeClassListTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassList is a list of RuntimeClass objects. type RuntimeClassListTypeOutput struct{ *pulumi.OutputState } @@ -502,6 +581,12 @@ func (o RuntimeClassListTypeOutput) ToRuntimeClassListTypeOutputWithContext(ctx return o } +func (o RuntimeClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassListType] { + return pulumix.Output[RuntimeClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -577,6 +662,12 @@ func (i RuntimeClassPatchTypeArgs) ToRuntimeClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchTypeOutput) } +func (i RuntimeClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassPatchType] { + return pulumix.Output[RuntimeClassPatchType]{ + OutputState: i.ToRuntimeClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md type RuntimeClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -592,6 +683,12 @@ func (o RuntimeClassPatchTypeOutput) ToRuntimeClassPatchTypeOutputWithContext(ct return o } +func (o RuntimeClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassPatchType] { + return pulumix.Output[RuntimeClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RuntimeClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -661,6 +758,12 @@ func (i SchedulingArgs) ToSchedulingOutputWithContext(ctx context.Context) Sched return pulumi.ToOutputWithContext(ctx, i).(SchedulingOutput) } +func (i SchedulingArgs) ToOutput(ctx context.Context) pulumix.Output[Scheduling] { + return pulumix.Output[Scheduling]{ + OutputState: i.ToSchedulingOutputWithContext(ctx).OutputState, + } +} + func (i SchedulingArgs) ToSchedulingPtrOutput() SchedulingPtrOutput { return i.ToSchedulingPtrOutputWithContext(context.Background()) } @@ -702,6 +805,12 @@ func (i *schedulingPtrType) ToSchedulingPtrOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(SchedulingPtrOutput) } +func (i *schedulingPtrType) ToOutput(ctx context.Context) pulumix.Output[*Scheduling] { + return pulumix.Output[*Scheduling]{ + OutputState: i.ToSchedulingPtrOutputWithContext(ctx).OutputState, + } +} + // Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. type SchedulingOutput struct{ *pulumi.OutputState } @@ -727,6 +836,12 @@ func (o SchedulingOutput) ToSchedulingPtrOutputWithContext(ctx context.Context) }).(SchedulingPtrOutput) } +func (o SchedulingOutput) ToOutput(ctx context.Context) pulumix.Output[Scheduling] { + return pulumix.Output[Scheduling]{ + OutputState: o.OutputState, + } +} + // nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. func (o SchedulingOutput) NodeSelector() pulumi.StringMapOutput { return o.ApplyT(func(v Scheduling) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput) @@ -751,6 +866,12 @@ func (o SchedulingPtrOutput) ToSchedulingPtrOutputWithContext(ctx context.Contex return o } +func (o SchedulingPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*Scheduling] { + return pulumix.Output[*Scheduling]{ + OutputState: o.OutputState, + } +} + func (o SchedulingPtrOutput) Elem() SchedulingOutput { return o.ApplyT(func(v *Scheduling) Scheduling { if v != nil { @@ -820,6 +941,12 @@ func (i SchedulingPatchArgs) ToSchedulingPatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchOutput) } +func (i SchedulingPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SchedulingPatch] { + return pulumix.Output[SchedulingPatch]{ + OutputState: i.ToSchedulingPatchOutputWithContext(ctx).OutputState, + } +} + func (i SchedulingPatchArgs) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput { return i.ToSchedulingPatchPtrOutputWithContext(context.Background()) } @@ -861,6 +988,12 @@ func (i *schedulingPatchPtrType) ToSchedulingPatchPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchPtrOutput) } +func (i *schedulingPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SchedulingPatch] { + return pulumix.Output[*SchedulingPatch]{ + OutputState: i.ToSchedulingPatchPtrOutputWithContext(ctx).OutputState, + } +} + // Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. type SchedulingPatchOutput struct{ *pulumi.OutputState } @@ -886,6 +1019,12 @@ func (o SchedulingPatchOutput) ToSchedulingPatchPtrOutputWithContext(ctx context }).(SchedulingPatchPtrOutput) } +func (o SchedulingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SchedulingPatch] { + return pulumix.Output[SchedulingPatch]{ + OutputState: o.OutputState, + } +} + // nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. func (o SchedulingPatchOutput) NodeSelector() pulumi.StringMapOutput { return o.ApplyT(func(v SchedulingPatch) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput) @@ -910,6 +1049,12 @@ func (o SchedulingPatchPtrOutput) ToSchedulingPatchPtrOutputWithContext(ctx cont return o } +func (o SchedulingPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SchedulingPatch] { + return pulumix.Output[*SchedulingPatch]{ + OutputState: o.OutputState, + } +} + func (o SchedulingPatchPtrOutput) Elem() SchedulingPatchOutput { return o.ApplyT(func(v *SchedulingPatch) SchedulingPatch { if v != nil { diff --git a/sdk/go/kubernetes/node/v1beta1/runtimeClass.go b/sdk/go/kubernetes/node/v1beta1/runtimeClass.go index 55299bcd61..204db5b7ba 100644 --- a/sdk/go/kubernetes/node/v1beta1/runtimeClass.go +++ b/sdk/go/kubernetes/node/v1beta1/runtimeClass.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md @@ -138,6 +139,12 @@ func (i *RuntimeClass) ToRuntimeClassOutputWithContext(ctx context.Context) Runt return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassOutput) } +func (i *RuntimeClass) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClass] { + return pulumix.Output[*RuntimeClass]{ + OutputState: i.ToRuntimeClassOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassArrayInput is an input type that accepts RuntimeClassArray and RuntimeClassArrayOutput values. // You can construct a concrete instance of `RuntimeClassArrayInput` via: // @@ -163,6 +170,12 @@ func (i RuntimeClassArray) ToRuntimeClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassArrayOutput) } +func (i RuntimeClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClass] { + return pulumix.Output[[]*RuntimeClass]{ + OutputState: i.ToRuntimeClassArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassMapInput is an input type that accepts RuntimeClassMap and RuntimeClassMapOutput values. // You can construct a concrete instance of `RuntimeClassMapInput` via: // @@ -188,6 +201,12 @@ func (i RuntimeClassMap) ToRuntimeClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassMapOutput) } +func (i RuntimeClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClass] { + return pulumix.Output[map[string]*RuntimeClass]{ + OutputState: i.ToRuntimeClassMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassOutput struct{ *pulumi.OutputState } func (RuntimeClassOutput) ElementType() reflect.Type { @@ -202,6 +221,12 @@ func (o RuntimeClassOutput) ToRuntimeClassOutputWithContext(ctx context.Context) return o } +func (o RuntimeClassOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClass] { + return pulumix.Output[*RuntimeClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RuntimeClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -246,6 +271,12 @@ func (o RuntimeClassArrayOutput) ToRuntimeClassArrayOutputWithContext(ctx contex return o } +func (o RuntimeClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClass] { + return pulumix.Output[[]*RuntimeClass]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassArrayOutput) Index(i pulumi.IntInput) RuntimeClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClass { return vs[0].([]*RuntimeClass)[vs[1].(int)] @@ -266,6 +297,12 @@ func (o RuntimeClassMapOutput) ToRuntimeClassMapOutputWithContext(ctx context.Co return o } +func (o RuntimeClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClass] { + return pulumix.Output[map[string]*RuntimeClass]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClass { return vs[0].(map[string]*RuntimeClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1beta1/runtimeClassList.go b/sdk/go/kubernetes/node/v1beta1/runtimeClassList.go index 71a0d026d5..a8edf2c94b 100644 --- a/sdk/go/kubernetes/node/v1beta1/runtimeClassList.go +++ b/sdk/go/kubernetes/node/v1beta1/runtimeClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RuntimeClassList is a list of RuntimeClass objects. @@ -117,6 +118,12 @@ func (i *RuntimeClassList) ToRuntimeClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListOutput) } +func (i *RuntimeClassList) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassList] { + return pulumix.Output[*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassListArrayInput is an input type that accepts RuntimeClassListArray and RuntimeClassListArrayOutput values. // You can construct a concrete instance of `RuntimeClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RuntimeClassListArray) ToRuntimeClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListArrayOutput) } +func (i RuntimeClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassList] { + return pulumix.Output[[]*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassListMapInput is an input type that accepts RuntimeClassListMap and RuntimeClassListMapOutput values. // You can construct a concrete instance of `RuntimeClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i RuntimeClassListMap) ToRuntimeClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListMapOutput) } +func (i RuntimeClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassList] { + return pulumix.Output[map[string]*RuntimeClassList]{ + OutputState: i.ToRuntimeClassListMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassListOutput struct{ *pulumi.OutputState } func (RuntimeClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RuntimeClassListOutput) ToRuntimeClassListOutputWithContext(ctx context. return o } +func (o RuntimeClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassList] { + return pulumix.Output[*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RuntimeClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RuntimeClassListArrayOutput) ToRuntimeClassListArrayOutputWithContext(ct return o } +func (o RuntimeClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassList] { + return pulumix.Output[[]*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassListArrayOutput) Index(i pulumi.IntInput) RuntimeClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClassList { return vs[0].([]*RuntimeClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RuntimeClassListMapOutput) ToRuntimeClassListMapOutputWithContext(ctx co return o } +func (o RuntimeClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassList] { + return pulumix.Output[map[string]*RuntimeClassList]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassListMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClassList { return vs[0].(map[string]*RuntimeClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/node/v1beta1/runtimeClassPatch.go b/sdk/go/kubernetes/node/v1beta1/runtimeClassPatch.go index 92bdd86fb8..d00ec78938 100644 --- a/sdk/go/kubernetes/node/v1beta1/runtimeClassPatch.go +++ b/sdk/go/kubernetes/node/v1beta1/runtimeClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -140,6 +141,12 @@ func (i *RuntimeClassPatch) ToRuntimeClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchOutput) } +func (i *RuntimeClassPatch) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassPatch] { + return pulumix.Output[*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassPatchArrayInput is an input type that accepts RuntimeClassPatchArray and RuntimeClassPatchArrayOutput values. // You can construct a concrete instance of `RuntimeClassPatchArrayInput` via: // @@ -165,6 +172,12 @@ func (i RuntimeClassPatchArray) ToRuntimeClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchArrayOutput) } +func (i RuntimeClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassPatch] { + return pulumix.Output[[]*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassPatchMapInput is an input type that accepts RuntimeClassPatchMap and RuntimeClassPatchMapOutput values. // You can construct a concrete instance of `RuntimeClassPatchMapInput` via: // @@ -190,6 +203,12 @@ func (i RuntimeClassPatchMap) ToRuntimeClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchMapOutput) } +func (i RuntimeClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassPatch] { + return pulumix.Output[map[string]*RuntimeClassPatch]{ + OutputState: i.ToRuntimeClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type RuntimeClassPatchOutput struct{ *pulumi.OutputState } func (RuntimeClassPatchOutput) ElementType() reflect.Type { @@ -204,6 +223,12 @@ func (o RuntimeClassPatchOutput) ToRuntimeClassPatchOutputWithContext(ctx contex return o } +func (o RuntimeClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassPatch] { + return pulumix.Output[*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RuntimeClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RuntimeClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -248,6 +273,12 @@ func (o RuntimeClassPatchArrayOutput) ToRuntimeClassPatchArrayOutputWithContext( return o } +func (o RuntimeClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuntimeClassPatch] { + return pulumix.Output[[]*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassPatchArrayOutput) Index(i pulumi.IntInput) RuntimeClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuntimeClassPatch { return vs[0].([]*RuntimeClassPatch)[vs[1].(int)] @@ -268,6 +299,12 @@ func (o RuntimeClassPatchMapOutput) ToRuntimeClassPatchMapOutputWithContext(ctx return o } +func (o RuntimeClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuntimeClassPatch] { + return pulumix.Output[map[string]*RuntimeClassPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassPatchMapOutput) MapIndex(k pulumi.StringInput) RuntimeClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuntimeClassPatch { return vs[0].(map[string]*RuntimeClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/pkg/version/pulumiTypes.go b/sdk/go/kubernetes/pkg/version/pulumiTypes.go index 15cf92c652..79a68e94ab 100644 --- a/sdk/go/kubernetes/pkg/version/pulumiTypes.go +++ b/sdk/go/kubernetes/pkg/version/pulumiTypes.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -62,6 +63,12 @@ func (i InfoArgs) ToInfoOutputWithContext(ctx context.Context) InfoOutput { return pulumi.ToOutputWithContext(ctx, i).(InfoOutput) } +func (i InfoArgs) ToOutput(ctx context.Context) pulumix.Output[Info] { + return pulumix.Output[Info]{ + OutputState: i.ToInfoOutputWithContext(ctx).OutputState, + } +} + // Info contains versioning information. how we'll want to distribute that information. type InfoOutput struct{ *pulumi.OutputState } @@ -77,6 +84,12 @@ func (o InfoOutput) ToInfoOutputWithContext(ctx context.Context) InfoOutput { return o } +func (o InfoOutput) ToOutput(ctx context.Context) pulumix.Output[Info] { + return pulumix.Output[Info]{ + OutputState: o.OutputState, + } +} + func (o InfoOutput) BuildDate() pulumi.StringOutput { return o.ApplyT(func(v Info) string { return v.BuildDate }).(pulumi.StringOutput) } @@ -162,6 +175,12 @@ func (i InfoPatchArgs) ToInfoPatchOutputWithContext(ctx context.Context) InfoPat return pulumi.ToOutputWithContext(ctx, i).(InfoPatchOutput) } +func (i InfoPatchArgs) ToOutput(ctx context.Context) pulumix.Output[InfoPatch] { + return pulumix.Output[InfoPatch]{ + OutputState: i.ToInfoPatchOutputWithContext(ctx).OutputState, + } +} + // Info contains versioning information. how we'll want to distribute that information. type InfoPatchOutput struct{ *pulumi.OutputState } @@ -177,6 +196,12 @@ func (o InfoPatchOutput) ToInfoPatchOutputWithContext(ctx context.Context) InfoP return o } +func (o InfoPatchOutput) ToOutput(ctx context.Context) pulumix.Output[InfoPatch] { + return pulumix.Output[InfoPatch]{ + OutputState: o.OutputState, + } +} + func (o InfoPatchOutput) BuildDate() pulumi.StringPtrOutput { return o.ApplyT(func(v InfoPatch) *string { return v.BuildDate }).(pulumi.StringPtrOutput) } diff --git a/sdk/go/kubernetes/policy/v1/podDisruptionBudget.go b/sdk/go/kubernetes/policy/v1/podDisruptionBudget.go index 0f34bef55c..9cc16fbbc8 100644 --- a/sdk/go/kubernetes/policy/v1/podDisruptionBudget.go +++ b/sdk/go/kubernetes/policy/v1/podDisruptionBudget.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods @@ -121,6 +122,12 @@ func (i *PodDisruptionBudget) ToPodDisruptionBudgetOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetOutput) } +func (i *PodDisruptionBudget) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudget] { + return pulumix.Output[*PodDisruptionBudget]{ + OutputState: i.ToPodDisruptionBudgetOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetArrayInput is an input type that accepts PodDisruptionBudgetArray and PodDisruptionBudgetArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetArrayInput` via: // @@ -146,6 +153,12 @@ func (i PodDisruptionBudgetArray) ToPodDisruptionBudgetArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetArrayOutput) } +func (i PodDisruptionBudgetArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudget] { + return pulumix.Output[[]*PodDisruptionBudget]{ + OutputState: i.ToPodDisruptionBudgetArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetMapInput is an input type that accepts PodDisruptionBudgetMap and PodDisruptionBudgetMapOutput values. // You can construct a concrete instance of `PodDisruptionBudgetMapInput` via: // @@ -171,6 +184,12 @@ func (i PodDisruptionBudgetMap) ToPodDisruptionBudgetMapOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetMapOutput) } +func (i PodDisruptionBudgetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudget] { + return pulumix.Output[map[string]*PodDisruptionBudget]{ + OutputState: i.ToPodDisruptionBudgetMapOutputWithContext(ctx).OutputState, + } +} + type PodDisruptionBudgetOutput struct{ *pulumi.OutputState } func (PodDisruptionBudgetOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o PodDisruptionBudgetOutput) ToPodDisruptionBudgetOutputWithContext(ctx co return o } +func (o PodDisruptionBudgetOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudget] { + return pulumix.Output[*PodDisruptionBudget]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodDisruptionBudget) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o PodDisruptionBudgetArrayOutput) ToPodDisruptionBudgetArrayOutputWithCont return o } +func (o PodDisruptionBudgetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudget] { + return pulumix.Output[[]*PodDisruptionBudget]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodDisruptionBudget { return vs[0].([]*PodDisruptionBudget)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o PodDisruptionBudgetMapOutput) ToPodDisruptionBudgetMapOutputWithContext( return o } +func (o PodDisruptionBudgetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudget] { + return pulumix.Output[map[string]*PodDisruptionBudget]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetMapOutput) MapIndex(k pulumi.StringInput) PodDisruptionBudgetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodDisruptionBudget { return vs[0].(map[string]*PodDisruptionBudget)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1/podDisruptionBudgetList.go b/sdk/go/kubernetes/policy/v1/podDisruptionBudgetList.go index 64bb563bf9..b5d5e12f36 100644 --- a/sdk/go/kubernetes/policy/v1/podDisruptionBudgetList.go +++ b/sdk/go/kubernetes/policy/v1/podDisruptionBudgetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodDisruptionBudgetList is a collection of PodDisruptionBudgets. @@ -117,6 +118,12 @@ func (i *PodDisruptionBudgetList) ToPodDisruptionBudgetListOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListOutput) } +func (i *PodDisruptionBudgetList) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetList] { + return pulumix.Output[*PodDisruptionBudgetList]{ + OutputState: i.ToPodDisruptionBudgetListOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetListArrayInput is an input type that accepts PodDisruptionBudgetListArray and PodDisruptionBudgetListArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodDisruptionBudgetListArray) ToPodDisruptionBudgetListArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListArrayOutput) } +func (i PodDisruptionBudgetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetList] { + return pulumix.Output[[]*PodDisruptionBudgetList]{ + OutputState: i.ToPodDisruptionBudgetListArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetListMapInput is an input type that accepts PodDisruptionBudgetListMap and PodDisruptionBudgetListMapOutput values. // You can construct a concrete instance of `PodDisruptionBudgetListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodDisruptionBudgetListMap) ToPodDisruptionBudgetListMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListMapOutput) } +func (i PodDisruptionBudgetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetList] { + return pulumix.Output[map[string]*PodDisruptionBudgetList]{ + OutputState: i.ToPodDisruptionBudgetListMapOutputWithContext(ctx).OutputState, + } +} + type PodDisruptionBudgetListOutput struct{ *pulumi.OutputState } func (PodDisruptionBudgetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodDisruptionBudgetListOutput) ToPodDisruptionBudgetListOutputWithContex return o } +func (o PodDisruptionBudgetListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetList] { + return pulumix.Output[*PodDisruptionBudgetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodDisruptionBudgetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodDisruptionBudgetListArrayOutput) ToPodDisruptionBudgetListArrayOutput return o } +func (o PodDisruptionBudgetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetList] { + return pulumix.Output[[]*PodDisruptionBudgetList]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetListArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodDisruptionBudgetList { return vs[0].([]*PodDisruptionBudgetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodDisruptionBudgetListMapOutput) ToPodDisruptionBudgetListMapOutputWith return o } +func (o PodDisruptionBudgetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetList] { + return pulumix.Output[map[string]*PodDisruptionBudgetList]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetListMapOutput) MapIndex(k pulumi.StringInput) PodDisruptionBudgetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodDisruptionBudgetList { return vs[0].(map[string]*PodDisruptionBudgetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1/podDisruptionBudgetPatch.go b/sdk/go/kubernetes/policy/v1/podDisruptionBudgetPatch.go index 6b18ac7d7d..969db95feb 100644 --- a/sdk/go/kubernetes/policy/v1/podDisruptionBudgetPatch.go +++ b/sdk/go/kubernetes/policy/v1/podDisruptionBudgetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -127,6 +128,12 @@ func (i *PodDisruptionBudgetPatch) ToPodDisruptionBudgetPatchOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchOutput) } +func (i *PodDisruptionBudgetPatch) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetPatch] { + return pulumix.Output[*PodDisruptionBudgetPatch]{ + OutputState: i.ToPodDisruptionBudgetPatchOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetPatchArrayInput is an input type that accepts PodDisruptionBudgetPatchArray and PodDisruptionBudgetPatchArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetPatchArrayInput` via: // @@ -152,6 +159,12 @@ func (i PodDisruptionBudgetPatchArray) ToPodDisruptionBudgetPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchArrayOutput) } +func (i PodDisruptionBudgetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetPatch] { + return pulumix.Output[[]*PodDisruptionBudgetPatch]{ + OutputState: i.ToPodDisruptionBudgetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetPatchMapInput is an input type that accepts PodDisruptionBudgetPatchMap and PodDisruptionBudgetPatchMapOutput values. // You can construct a concrete instance of `PodDisruptionBudgetPatchMapInput` via: // @@ -177,6 +190,12 @@ func (i PodDisruptionBudgetPatchMap) ToPodDisruptionBudgetPatchMapOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchMapOutput) } +func (i PodDisruptionBudgetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetPatch] { + return pulumix.Output[map[string]*PodDisruptionBudgetPatch]{ + OutputState: i.ToPodDisruptionBudgetPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodDisruptionBudgetPatchOutput struct{ *pulumi.OutputState } func (PodDisruptionBudgetPatchOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o PodDisruptionBudgetPatchOutput) ToPodDisruptionBudgetPatchOutputWithCont return o } +func (o PodDisruptionBudgetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetPatch] { + return pulumix.Output[*PodDisruptionBudgetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodDisruptionBudgetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -230,6 +255,12 @@ func (o PodDisruptionBudgetPatchArrayOutput) ToPodDisruptionBudgetPatchArrayOutp return o } +func (o PodDisruptionBudgetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetPatch] { + return pulumix.Output[[]*PodDisruptionBudgetPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetPatchArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodDisruptionBudgetPatch { return vs[0].([]*PodDisruptionBudgetPatch)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o PodDisruptionBudgetPatchMapOutput) ToPodDisruptionBudgetPatchMapOutputWi return o } +func (o PodDisruptionBudgetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetPatch] { + return pulumix.Output[map[string]*PodDisruptionBudgetPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetPatchMapOutput) MapIndex(k pulumi.StringInput) PodDisruptionBudgetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodDisruptionBudgetPatch { return vs[0].(map[string]*PodDisruptionBudgetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1/pulumiTypes.go b/sdk/go/kubernetes/policy/v1/pulumiTypes.go index a11504883f..13986f8212 100644 --- a/sdk/go/kubernetes/policy/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/policy/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -61,6 +62,12 @@ func (i EvictionArgs) ToEvictionOutputWithContext(ctx context.Context) EvictionO return pulumi.ToOutputWithContext(ctx, i).(EvictionOutput) } +func (i EvictionArgs) ToOutput(ctx context.Context) pulumix.Output[Eviction] { + return pulumix.Output[Eviction]{ + OutputState: i.ToEvictionOutputWithContext(ctx).OutputState, + } +} + // Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions. type EvictionOutput struct{ *pulumi.OutputState } @@ -76,6 +83,12 @@ func (o EvictionOutput) ToEvictionOutputWithContext(ctx context.Context) Evictio return o } +func (o EvictionOutput) ToOutput(ctx context.Context) pulumix.Output[Eviction] { + return pulumix.Output[Eviction]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EvictionOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Eviction) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -143,6 +156,12 @@ func (i EvictionPatchArgs) ToEvictionPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EvictionPatchOutput) } +func (i EvictionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EvictionPatch] { + return pulumix.Output[EvictionPatch]{ + OutputState: i.ToEvictionPatchOutputWithContext(ctx).OutputState, + } +} + // Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions. type EvictionPatchOutput struct{ *pulumi.OutputState } @@ -158,6 +177,12 @@ func (o EvictionPatchOutput) ToEvictionPatchOutputWithContext(ctx context.Contex return o } +func (o EvictionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EvictionPatch] { + return pulumix.Output[EvictionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EvictionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EvictionPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -229,6 +254,12 @@ func (i PodDisruptionBudgetTypeArgs) ToPodDisruptionBudgetTypeOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetTypeOutput) } +func (i PodDisruptionBudgetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetType] { + return pulumix.Output[PodDisruptionBudgetType]{ + OutputState: i.ToPodDisruptionBudgetTypeOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetTypeArrayInput is an input type that accepts PodDisruptionBudgetTypeArray and PodDisruptionBudgetTypeArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetTypeArrayInput` via: // @@ -254,6 +285,12 @@ func (i PodDisruptionBudgetTypeArray) ToPodDisruptionBudgetTypeArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetTypeArrayOutput) } +func (i PodDisruptionBudgetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodDisruptionBudgetType] { + return pulumix.Output[[]PodDisruptionBudgetType]{ + OutputState: i.ToPodDisruptionBudgetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods type PodDisruptionBudgetTypeOutput struct{ *pulumi.OutputState } @@ -269,6 +306,12 @@ func (o PodDisruptionBudgetTypeOutput) ToPodDisruptionBudgetTypeOutputWithContex return o } +func (o PodDisruptionBudgetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetType] { + return pulumix.Output[PodDisruptionBudgetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -308,6 +351,12 @@ func (o PodDisruptionBudgetTypeArrayOutput) ToPodDisruptionBudgetTypeArrayOutput return o } +func (o PodDisruptionBudgetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodDisruptionBudgetType] { + return pulumix.Output[[]PodDisruptionBudgetType]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetTypeArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodDisruptionBudgetType { return vs[0].([]PodDisruptionBudgetType)[vs[1].(int)] @@ -361,6 +410,12 @@ func (i PodDisruptionBudgetListTypeArgs) ToPodDisruptionBudgetListTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListTypeOutput) } +func (i PodDisruptionBudgetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetListType] { + return pulumix.Output[PodDisruptionBudgetListType]{ + OutputState: i.ToPodDisruptionBudgetListTypeOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetList is a collection of PodDisruptionBudgets. type PodDisruptionBudgetListTypeOutput struct{ *pulumi.OutputState } @@ -376,6 +431,12 @@ func (o PodDisruptionBudgetListTypeOutput) ToPodDisruptionBudgetListTypeOutputWi return o } +func (o PodDisruptionBudgetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetListType] { + return pulumix.Output[PodDisruptionBudgetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -447,6 +508,12 @@ func (i PodDisruptionBudgetPatchTypeArgs) ToPodDisruptionBudgetPatchTypeOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchTypeOutput) } +func (i PodDisruptionBudgetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetPatchType] { + return pulumix.Output[PodDisruptionBudgetPatchType]{ + OutputState: i.ToPodDisruptionBudgetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods type PodDisruptionBudgetPatchTypeOutput struct{ *pulumi.OutputState } @@ -462,6 +529,12 @@ func (o PodDisruptionBudgetPatchTypeOutput) ToPodDisruptionBudgetPatchTypeOutput return o } +func (o PodDisruptionBudgetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetPatchType] { + return pulumix.Output[PodDisruptionBudgetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -554,6 +627,12 @@ func (i PodDisruptionBudgetSpecArgs) ToPodDisruptionBudgetSpecOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecOutput) } +func (i PodDisruptionBudgetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpec] { + return pulumix.Output[PodDisruptionBudgetSpec]{ + OutputState: i.ToPodDisruptionBudgetSpecOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetSpecArgs) ToPodDisruptionBudgetSpecPtrOutput() PodDisruptionBudgetSpecPtrOutput { return i.ToPodDisruptionBudgetSpecPtrOutputWithContext(context.Background()) } @@ -595,6 +674,12 @@ func (i *podDisruptionBudgetSpecPtrType) ToPodDisruptionBudgetSpecPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecPtrOutput) } +func (i *podDisruptionBudgetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpec] { + return pulumix.Output[*PodDisruptionBudgetSpec]{ + OutputState: i.ToPodDisruptionBudgetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetSpec is a description of a PodDisruptionBudget. type PodDisruptionBudgetSpecOutput struct{ *pulumi.OutputState } @@ -620,6 +705,12 @@ func (o PodDisruptionBudgetSpecOutput) ToPodDisruptionBudgetSpecPtrOutputWithCon }).(PodDisruptionBudgetSpecPtrOutput) } +func (o PodDisruptionBudgetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpec] { + return pulumix.Output[PodDisruptionBudgetSpec]{ + OutputState: o.OutputState, + } +} + // An eviction is allowed if at most "maxUnavailable" pods selected by "selector" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with "minAvailable". func (o PodDisruptionBudgetSpecOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v PodDisruptionBudgetSpec) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -664,6 +755,12 @@ func (o PodDisruptionBudgetSpecPtrOutput) ToPodDisruptionBudgetSpecPtrOutputWith return o } +func (o PodDisruptionBudgetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpec] { + return pulumix.Output[*PodDisruptionBudgetSpec]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetSpecPtrOutput) Elem() PodDisruptionBudgetSpecOutput { return o.ApplyT(func(v *PodDisruptionBudgetSpec) PodDisruptionBudgetSpec { if v != nil { @@ -791,6 +888,12 @@ func (i PodDisruptionBudgetSpecPatchArgs) ToPodDisruptionBudgetSpecPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecPatchOutput) } +func (i PodDisruptionBudgetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpecPatch] { + return pulumix.Output[PodDisruptionBudgetSpecPatch]{ + OutputState: i.ToPodDisruptionBudgetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetSpecPatchArgs) ToPodDisruptionBudgetSpecPatchPtrOutput() PodDisruptionBudgetSpecPatchPtrOutput { return i.ToPodDisruptionBudgetSpecPatchPtrOutputWithContext(context.Background()) } @@ -832,6 +935,12 @@ func (i *podDisruptionBudgetSpecPatchPtrType) ToPodDisruptionBudgetSpecPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecPatchPtrOutput) } +func (i *podDisruptionBudgetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpecPatch] { + return pulumix.Output[*PodDisruptionBudgetSpecPatch]{ + OutputState: i.ToPodDisruptionBudgetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetSpec is a description of a PodDisruptionBudget. type PodDisruptionBudgetSpecPatchOutput struct{ *pulumi.OutputState } @@ -857,6 +966,12 @@ func (o PodDisruptionBudgetSpecPatchOutput) ToPodDisruptionBudgetSpecPatchPtrOut }).(PodDisruptionBudgetSpecPatchPtrOutput) } +func (o PodDisruptionBudgetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpecPatch] { + return pulumix.Output[PodDisruptionBudgetSpecPatch]{ + OutputState: o.OutputState, + } +} + // An eviction is allowed if at most "maxUnavailable" pods selected by "selector" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with "minAvailable". func (o PodDisruptionBudgetSpecPatchOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v PodDisruptionBudgetSpecPatch) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -901,6 +1016,12 @@ func (o PodDisruptionBudgetSpecPatchPtrOutput) ToPodDisruptionBudgetSpecPatchPtr return o } +func (o PodDisruptionBudgetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpecPatch] { + return pulumix.Output[*PodDisruptionBudgetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetSpecPatchPtrOutput) Elem() PodDisruptionBudgetSpecPatchOutput { return o.ApplyT(func(v *PodDisruptionBudgetSpecPatch) PodDisruptionBudgetSpecPatch { if v != nil { @@ -1036,6 +1157,12 @@ func (i PodDisruptionBudgetStatusArgs) ToPodDisruptionBudgetStatusOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusOutput) } +func (i PodDisruptionBudgetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatus] { + return pulumix.Output[PodDisruptionBudgetStatus]{ + OutputState: i.ToPodDisruptionBudgetStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetStatusArgs) ToPodDisruptionBudgetStatusPtrOutput() PodDisruptionBudgetStatusPtrOutput { return i.ToPodDisruptionBudgetStatusPtrOutputWithContext(context.Background()) } @@ -1077,6 +1204,12 @@ func (i *podDisruptionBudgetStatusPtrType) ToPodDisruptionBudgetStatusPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusPtrOutput) } +func (i *podDisruptionBudgetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatus] { + return pulumix.Output[*PodDisruptionBudgetStatus]{ + OutputState: i.ToPodDisruptionBudgetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system. type PodDisruptionBudgetStatusOutput struct{ *pulumi.OutputState } @@ -1102,6 +1235,12 @@ func (o PodDisruptionBudgetStatusOutput) ToPodDisruptionBudgetStatusPtrOutputWit }).(PodDisruptionBudgetStatusPtrOutput) } +func (o PodDisruptionBudgetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatus] { + return pulumix.Output[PodDisruptionBudgetStatus]{ + OutputState: o.OutputState, + } +} + // Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute // // the number of allowed disruptions. Therefore no disruptions are @@ -1160,6 +1299,12 @@ func (o PodDisruptionBudgetStatusPtrOutput) ToPodDisruptionBudgetStatusPtrOutput return o } +func (o PodDisruptionBudgetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatus] { + return pulumix.Output[*PodDisruptionBudgetStatus]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetStatusPtrOutput) Elem() PodDisruptionBudgetStatusOutput { return o.ApplyT(func(v *PodDisruptionBudgetStatus) PodDisruptionBudgetStatus { if v != nil { @@ -1324,6 +1469,12 @@ func (i PodDisruptionBudgetStatusPatchArgs) ToPodDisruptionBudgetStatusPatchOutp return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusPatchOutput) } +func (i PodDisruptionBudgetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatusPatch] { + return pulumix.Output[PodDisruptionBudgetStatusPatch]{ + OutputState: i.ToPodDisruptionBudgetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetStatusPatchArgs) ToPodDisruptionBudgetStatusPatchPtrOutput() PodDisruptionBudgetStatusPatchPtrOutput { return i.ToPodDisruptionBudgetStatusPatchPtrOutputWithContext(context.Background()) } @@ -1365,6 +1516,12 @@ func (i *podDisruptionBudgetStatusPatchPtrType) ToPodDisruptionBudgetStatusPatch return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusPatchPtrOutput) } +func (i *podDisruptionBudgetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatusPatch] { + return pulumix.Output[*PodDisruptionBudgetStatusPatch]{ + OutputState: i.ToPodDisruptionBudgetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system. type PodDisruptionBudgetStatusPatchOutput struct{ *pulumi.OutputState } @@ -1390,6 +1547,12 @@ func (o PodDisruptionBudgetStatusPatchOutput) ToPodDisruptionBudgetStatusPatchPt }).(PodDisruptionBudgetStatusPatchPtrOutput) } +func (o PodDisruptionBudgetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatusPatch] { + return pulumix.Output[PodDisruptionBudgetStatusPatch]{ + OutputState: o.OutputState, + } +} + // Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute // // the number of allowed disruptions. Therefore no disruptions are @@ -1448,6 +1611,12 @@ func (o PodDisruptionBudgetStatusPatchPtrOutput) ToPodDisruptionBudgetStatusPatc return o } +func (o PodDisruptionBudgetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatusPatch] { + return pulumix.Output[*PodDisruptionBudgetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetStatusPatchPtrOutput) Elem() PodDisruptionBudgetStatusPatchOutput { return o.ApplyT(func(v *PodDisruptionBudgetStatusPatch) PodDisruptionBudgetStatusPatch { if v != nil { diff --git a/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudget.go b/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudget.go index d46f191a12..2633a68fff 100644 --- a/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudget.go +++ b/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudget.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods @@ -118,6 +119,12 @@ func (i *PodDisruptionBudget) ToPodDisruptionBudgetOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetOutput) } +func (i *PodDisruptionBudget) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudget] { + return pulumix.Output[*PodDisruptionBudget]{ + OutputState: i.ToPodDisruptionBudgetOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetArrayInput is an input type that accepts PodDisruptionBudgetArray and PodDisruptionBudgetArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetArrayInput` via: // @@ -143,6 +150,12 @@ func (i PodDisruptionBudgetArray) ToPodDisruptionBudgetArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetArrayOutput) } +func (i PodDisruptionBudgetArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudget] { + return pulumix.Output[[]*PodDisruptionBudget]{ + OutputState: i.ToPodDisruptionBudgetArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetMapInput is an input type that accepts PodDisruptionBudgetMap and PodDisruptionBudgetMapOutput values. // You can construct a concrete instance of `PodDisruptionBudgetMapInput` via: // @@ -168,6 +181,12 @@ func (i PodDisruptionBudgetMap) ToPodDisruptionBudgetMapOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetMapOutput) } +func (i PodDisruptionBudgetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudget] { + return pulumix.Output[map[string]*PodDisruptionBudget]{ + OutputState: i.ToPodDisruptionBudgetMapOutputWithContext(ctx).OutputState, + } +} + type PodDisruptionBudgetOutput struct{ *pulumi.OutputState } func (PodDisruptionBudgetOutput) ElementType() reflect.Type { @@ -182,6 +201,12 @@ func (o PodDisruptionBudgetOutput) ToPodDisruptionBudgetOutputWithContext(ctx co return o } +func (o PodDisruptionBudgetOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudget] { + return pulumix.Output[*PodDisruptionBudget]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodDisruptionBudget) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -220,6 +245,12 @@ func (o PodDisruptionBudgetArrayOutput) ToPodDisruptionBudgetArrayOutputWithCont return o } +func (o PodDisruptionBudgetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudget] { + return pulumix.Output[[]*PodDisruptionBudget]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodDisruptionBudget { return vs[0].([]*PodDisruptionBudget)[vs[1].(int)] @@ -240,6 +271,12 @@ func (o PodDisruptionBudgetMapOutput) ToPodDisruptionBudgetMapOutputWithContext( return o } +func (o PodDisruptionBudgetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudget] { + return pulumix.Output[map[string]*PodDisruptionBudget]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetMapOutput) MapIndex(k pulumi.StringInput) PodDisruptionBudgetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodDisruptionBudget { return vs[0].(map[string]*PodDisruptionBudget)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetList.go b/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetList.go index c9e6b5d0f1..a43f2faca9 100644 --- a/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetList.go +++ b/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodDisruptionBudgetList is a collection of PodDisruptionBudgets. @@ -111,6 +112,12 @@ func (i *PodDisruptionBudgetList) ToPodDisruptionBudgetListOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListOutput) } +func (i *PodDisruptionBudgetList) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetList] { + return pulumix.Output[*PodDisruptionBudgetList]{ + OutputState: i.ToPodDisruptionBudgetListOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetListArrayInput is an input type that accepts PodDisruptionBudgetListArray and PodDisruptionBudgetListArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetListArrayInput` via: // @@ -136,6 +143,12 @@ func (i PodDisruptionBudgetListArray) ToPodDisruptionBudgetListArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListArrayOutput) } +func (i PodDisruptionBudgetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetList] { + return pulumix.Output[[]*PodDisruptionBudgetList]{ + OutputState: i.ToPodDisruptionBudgetListArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetListMapInput is an input type that accepts PodDisruptionBudgetListMap and PodDisruptionBudgetListMapOutput values. // You can construct a concrete instance of `PodDisruptionBudgetListMapInput` via: // @@ -161,6 +174,12 @@ func (i PodDisruptionBudgetListMap) ToPodDisruptionBudgetListMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListMapOutput) } +func (i PodDisruptionBudgetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetList] { + return pulumix.Output[map[string]*PodDisruptionBudgetList]{ + OutputState: i.ToPodDisruptionBudgetListMapOutputWithContext(ctx).OutputState, + } +} + type PodDisruptionBudgetListOutput struct{ *pulumi.OutputState } func (PodDisruptionBudgetListOutput) ElementType() reflect.Type { @@ -175,6 +194,12 @@ func (o PodDisruptionBudgetListOutput) ToPodDisruptionBudgetListOutputWithContex return o } +func (o PodDisruptionBudgetListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetList] { + return pulumix.Output[*PodDisruptionBudgetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodDisruptionBudgetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -207,6 +232,12 @@ func (o PodDisruptionBudgetListArrayOutput) ToPodDisruptionBudgetListArrayOutput return o } +func (o PodDisruptionBudgetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetList] { + return pulumix.Output[[]*PodDisruptionBudgetList]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetListArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodDisruptionBudgetList { return vs[0].([]*PodDisruptionBudgetList)[vs[1].(int)] @@ -227,6 +258,12 @@ func (o PodDisruptionBudgetListMapOutput) ToPodDisruptionBudgetListMapOutputWith return o } +func (o PodDisruptionBudgetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetList] { + return pulumix.Output[map[string]*PodDisruptionBudgetList]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetListMapOutput) MapIndex(k pulumi.StringInput) PodDisruptionBudgetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodDisruptionBudgetList { return vs[0].(map[string]*PodDisruptionBudgetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetPatch.go b/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetPatch.go index 3655f58d6e..f72bd4af79 100644 --- a/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetPatch.go +++ b/sdk/go/kubernetes/policy/v1beta1/podDisruptionBudgetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -124,6 +125,12 @@ func (i *PodDisruptionBudgetPatch) ToPodDisruptionBudgetPatchOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchOutput) } +func (i *PodDisruptionBudgetPatch) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetPatch] { + return pulumix.Output[*PodDisruptionBudgetPatch]{ + OutputState: i.ToPodDisruptionBudgetPatchOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetPatchArrayInput is an input type that accepts PodDisruptionBudgetPatchArray and PodDisruptionBudgetPatchArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetPatchArrayInput` via: // @@ -149,6 +156,12 @@ func (i PodDisruptionBudgetPatchArray) ToPodDisruptionBudgetPatchArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchArrayOutput) } +func (i PodDisruptionBudgetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetPatch] { + return pulumix.Output[[]*PodDisruptionBudgetPatch]{ + OutputState: i.ToPodDisruptionBudgetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetPatchMapInput is an input type that accepts PodDisruptionBudgetPatchMap and PodDisruptionBudgetPatchMapOutput values. // You can construct a concrete instance of `PodDisruptionBudgetPatchMapInput` via: // @@ -174,6 +187,12 @@ func (i PodDisruptionBudgetPatchMap) ToPodDisruptionBudgetPatchMapOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchMapOutput) } +func (i PodDisruptionBudgetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetPatch] { + return pulumix.Output[map[string]*PodDisruptionBudgetPatch]{ + OutputState: i.ToPodDisruptionBudgetPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodDisruptionBudgetPatchOutput struct{ *pulumi.OutputState } func (PodDisruptionBudgetPatchOutput) ElementType() reflect.Type { @@ -188,6 +207,12 @@ func (o PodDisruptionBudgetPatchOutput) ToPodDisruptionBudgetPatchOutputWithCont return o } +func (o PodDisruptionBudgetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetPatch] { + return pulumix.Output[*PodDisruptionBudgetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodDisruptionBudgetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o PodDisruptionBudgetPatchArrayOutput) ToPodDisruptionBudgetPatchArrayOutp return o } +func (o PodDisruptionBudgetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodDisruptionBudgetPatch] { + return pulumix.Output[[]*PodDisruptionBudgetPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetPatchArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodDisruptionBudgetPatch { return vs[0].([]*PodDisruptionBudgetPatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o PodDisruptionBudgetPatchMapOutput) ToPodDisruptionBudgetPatchMapOutputWi return o } +func (o PodDisruptionBudgetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodDisruptionBudgetPatch] { + return pulumix.Output[map[string]*PodDisruptionBudgetPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetPatchMapOutput) MapIndex(k pulumi.StringInput) PodDisruptionBudgetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodDisruptionBudgetPatch { return vs[0].(map[string]*PodDisruptionBudgetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicy.go b/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicy.go index 90b7209725..32045bf894 100644 --- a/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicy.go +++ b/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicy.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. @@ -119,6 +120,12 @@ func (i *PodSecurityPolicy) ToPodSecurityPolicyOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyOutput) } +func (i *PodSecurityPolicy) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicy] { + return pulumix.Output[*PodSecurityPolicy]{ + OutputState: i.ToPodSecurityPolicyOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyArrayInput is an input type that accepts PodSecurityPolicyArray and PodSecurityPolicyArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyArrayInput` via: // @@ -144,6 +151,12 @@ func (i PodSecurityPolicyArray) ToPodSecurityPolicyArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyArrayOutput) } +func (i PodSecurityPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicy] { + return pulumix.Output[[]*PodSecurityPolicy]{ + OutputState: i.ToPodSecurityPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyMapInput is an input type that accepts PodSecurityPolicyMap and PodSecurityPolicyMapOutput values. // You can construct a concrete instance of `PodSecurityPolicyMapInput` via: // @@ -169,6 +182,12 @@ func (i PodSecurityPolicyMap) ToPodSecurityPolicyMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyMapOutput) } +func (i PodSecurityPolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicy] { + return pulumix.Output[map[string]*PodSecurityPolicy]{ + OutputState: i.ToPodSecurityPolicyMapOutputWithContext(ctx).OutputState, + } +} + type PodSecurityPolicyOutput struct{ *pulumi.OutputState } func (PodSecurityPolicyOutput) ElementType() reflect.Type { @@ -183,6 +202,12 @@ func (o PodSecurityPolicyOutput) ToPodSecurityPolicyOutputWithContext(ctx contex return o } +func (o PodSecurityPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicy] { + return pulumix.Output[*PodSecurityPolicy]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSecurityPolicy) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -217,6 +242,12 @@ func (o PodSecurityPolicyArrayOutput) ToPodSecurityPolicyArrayOutputWithContext( return o } +func (o PodSecurityPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicy] { + return pulumix.Output[[]*PodSecurityPolicy]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSecurityPolicy { return vs[0].([]*PodSecurityPolicy)[vs[1].(int)] @@ -237,6 +268,12 @@ func (o PodSecurityPolicyMapOutput) ToPodSecurityPolicyMapOutputWithContext(ctx return o } +func (o PodSecurityPolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicy] { + return pulumix.Output[map[string]*PodSecurityPolicy]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyMapOutput) MapIndex(k pulumi.StringInput) PodSecurityPolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSecurityPolicy { return vs[0].(map[string]*PodSecurityPolicy)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyList.go b/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyList.go index db413d2407..67d927c17c 100644 --- a/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyList.go +++ b/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSecurityPolicyList is a list of PodSecurityPolicy objects. @@ -117,6 +118,12 @@ func (i *PodSecurityPolicyList) ToPodSecurityPolicyListOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListOutput) } +func (i *PodSecurityPolicyList) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyList] { + return pulumix.Output[*PodSecurityPolicyList]{ + OutputState: i.ToPodSecurityPolicyListOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyListArrayInput is an input type that accepts PodSecurityPolicyListArray and PodSecurityPolicyListArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodSecurityPolicyListArray) ToPodSecurityPolicyListArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListArrayOutput) } +func (i PodSecurityPolicyListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyList] { + return pulumix.Output[[]*PodSecurityPolicyList]{ + OutputState: i.ToPodSecurityPolicyListArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyListMapInput is an input type that accepts PodSecurityPolicyListMap and PodSecurityPolicyListMapOutput values. // You can construct a concrete instance of `PodSecurityPolicyListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodSecurityPolicyListMap) ToPodSecurityPolicyListMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListMapOutput) } +func (i PodSecurityPolicyListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyList] { + return pulumix.Output[map[string]*PodSecurityPolicyList]{ + OutputState: i.ToPodSecurityPolicyListMapOutputWithContext(ctx).OutputState, + } +} + type PodSecurityPolicyListOutput struct{ *pulumi.OutputState } func (PodSecurityPolicyListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodSecurityPolicyListOutput) ToPodSecurityPolicyListOutputWithContext(ct return o } +func (o PodSecurityPolicyListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyList] { + return pulumix.Output[*PodSecurityPolicyList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSecurityPolicyList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodSecurityPolicyListArrayOutput) ToPodSecurityPolicyListArrayOutputWith return o } +func (o PodSecurityPolicyListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyList] { + return pulumix.Output[[]*PodSecurityPolicyList]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyListArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSecurityPolicyList { return vs[0].([]*PodSecurityPolicyList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodSecurityPolicyListMapOutput) ToPodSecurityPolicyListMapOutputWithCont return o } +func (o PodSecurityPolicyListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyList] { + return pulumix.Output[map[string]*PodSecurityPolicyList]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyListMapOutput) MapIndex(k pulumi.StringInput) PodSecurityPolicyListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSecurityPolicyList { return vs[0].(map[string]*PodSecurityPolicyList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyPatch.go b/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyPatch.go index 227c274639..9e29e185fd 100644 --- a/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyPatch.go +++ b/sdk/go/kubernetes/policy/v1beta1/podSecurityPolicyPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *PodSecurityPolicyPatch) ToPodSecurityPolicyPatchOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchOutput) } +func (i *PodSecurityPolicyPatch) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyPatch] { + return pulumix.Output[*PodSecurityPolicyPatch]{ + OutputState: i.ToPodSecurityPolicyPatchOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyPatchArrayInput is an input type that accepts PodSecurityPolicyPatchArray and PodSecurityPolicyPatchArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i PodSecurityPolicyPatchArray) ToPodSecurityPolicyPatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchArrayOutput) } +func (i PodSecurityPolicyPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyPatch] { + return pulumix.Output[[]*PodSecurityPolicyPatch]{ + OutputState: i.ToPodSecurityPolicyPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyPatchMapInput is an input type that accepts PodSecurityPolicyPatchMap and PodSecurityPolicyPatchMapOutput values. // You can construct a concrete instance of `PodSecurityPolicyPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i PodSecurityPolicyPatchMap) ToPodSecurityPolicyPatchMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchMapOutput) } +func (i PodSecurityPolicyPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyPatch] { + return pulumix.Output[map[string]*PodSecurityPolicyPatch]{ + OutputState: i.ToPodSecurityPolicyPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodSecurityPolicyPatchOutput struct{ *pulumi.OutputState } func (PodSecurityPolicyPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o PodSecurityPolicyPatchOutput) ToPodSecurityPolicyPatchOutputWithContext( return o } +func (o PodSecurityPolicyPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicyPatch] { + return pulumix.Output[*PodSecurityPolicyPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodSecurityPolicyPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o PodSecurityPolicyPatchArrayOutput) ToPodSecurityPolicyPatchArrayOutputWi return o } +func (o PodSecurityPolicyPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSecurityPolicyPatch] { + return pulumix.Output[[]*PodSecurityPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyPatchArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSecurityPolicyPatch { return vs[0].([]*PodSecurityPolicyPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o PodSecurityPolicyPatchMapOutput) ToPodSecurityPolicyPatchMapOutputWithCo return o } +func (o PodSecurityPolicyPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSecurityPolicyPatch] { + return pulumix.Output[map[string]*PodSecurityPolicyPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyPatchMapOutput) MapIndex(k pulumi.StringInput) PodSecurityPolicyPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSecurityPolicyPatch { return vs[0].(map[string]*PodSecurityPolicyPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/policy/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/policy/v1beta1/pulumiTypes.go index b3f4e9fb65..1d3b30a6ae 100644 --- a/sdk/go/kubernetes/policy/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/policy/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -50,6 +51,12 @@ func (i AllowedCSIDriverArgs) ToAllowedCSIDriverOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverOutput) } +func (i AllowedCSIDriverArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriver] { + return pulumix.Output[AllowedCSIDriver]{ + OutputState: i.ToAllowedCSIDriverOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriverArrayInput is an input type that accepts AllowedCSIDriverArray and AllowedCSIDriverArrayOutput values. // You can construct a concrete instance of `AllowedCSIDriverArrayInput` via: // @@ -75,6 +82,12 @@ func (i AllowedCSIDriverArray) ToAllowedCSIDriverArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverArrayOutput) } +func (i AllowedCSIDriverArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriver] { + return pulumix.Output[[]AllowedCSIDriver]{ + OutputState: i.ToAllowedCSIDriverArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriver represents a single inline CSI Driver that is allowed to be used. type AllowedCSIDriverOutput struct{ *pulumi.OutputState } @@ -90,6 +103,12 @@ func (o AllowedCSIDriverOutput) ToAllowedCSIDriverOutputWithContext(ctx context. return o } +func (o AllowedCSIDriverOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriver] { + return pulumix.Output[AllowedCSIDriver]{ + OutputState: o.OutputState, + } +} + // Name is the registered name of the CSI driver func (o AllowedCSIDriverOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v AllowedCSIDriver) string { return v.Name }).(pulumi.StringOutput) @@ -109,6 +128,12 @@ func (o AllowedCSIDriverArrayOutput) ToAllowedCSIDriverArrayOutputWithContext(ct return o } +func (o AllowedCSIDriverArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriver] { + return pulumix.Output[[]AllowedCSIDriver]{ + OutputState: o.OutputState, + } +} + func (o AllowedCSIDriverArrayOutput) Index(i pulumi.IntInput) AllowedCSIDriverOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedCSIDriver { return vs[0].([]AllowedCSIDriver)[vs[1].(int)] @@ -150,6 +175,12 @@ func (i AllowedCSIDriverPatchArgs) ToAllowedCSIDriverPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverPatchOutput) } +func (i AllowedCSIDriverPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriverPatch] { + return pulumix.Output[AllowedCSIDriverPatch]{ + OutputState: i.ToAllowedCSIDriverPatchOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriverPatchArrayInput is an input type that accepts AllowedCSIDriverPatchArray and AllowedCSIDriverPatchArrayOutput values. // You can construct a concrete instance of `AllowedCSIDriverPatchArrayInput` via: // @@ -175,6 +206,12 @@ func (i AllowedCSIDriverPatchArray) ToAllowedCSIDriverPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(AllowedCSIDriverPatchArrayOutput) } +func (i AllowedCSIDriverPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriverPatch] { + return pulumix.Output[[]AllowedCSIDriverPatch]{ + OutputState: i.ToAllowedCSIDriverPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedCSIDriver represents a single inline CSI Driver that is allowed to be used. type AllowedCSIDriverPatchOutput struct{ *pulumi.OutputState } @@ -190,6 +227,12 @@ func (o AllowedCSIDriverPatchOutput) ToAllowedCSIDriverPatchOutputWithContext(ct return o } +func (o AllowedCSIDriverPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedCSIDriverPatch] { + return pulumix.Output[AllowedCSIDriverPatch]{ + OutputState: o.OutputState, + } +} + // Name is the registered name of the CSI driver func (o AllowedCSIDriverPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v AllowedCSIDriverPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -209,6 +252,12 @@ func (o AllowedCSIDriverPatchArrayOutput) ToAllowedCSIDriverPatchArrayOutputWith return o } +func (o AllowedCSIDriverPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedCSIDriverPatch] { + return pulumix.Output[[]AllowedCSIDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o AllowedCSIDriverPatchArrayOutput) Index(i pulumi.IntInput) AllowedCSIDriverPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedCSIDriverPatch { return vs[0].([]AllowedCSIDriverPatch)[vs[1].(int)] @@ -250,6 +299,12 @@ func (i AllowedFlexVolumeArgs) ToAllowedFlexVolumeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumeOutput) } +func (i AllowedFlexVolumeArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolume] { + return pulumix.Output[AllowedFlexVolume]{ + OutputState: i.ToAllowedFlexVolumeOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolumeArrayInput is an input type that accepts AllowedFlexVolumeArray and AllowedFlexVolumeArrayOutput values. // You can construct a concrete instance of `AllowedFlexVolumeArrayInput` via: // @@ -275,6 +330,12 @@ func (i AllowedFlexVolumeArray) ToAllowedFlexVolumeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumeArrayOutput) } +func (i AllowedFlexVolumeArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolume] { + return pulumix.Output[[]AllowedFlexVolume]{ + OutputState: i.ToAllowedFlexVolumeArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolume represents a single Flexvolume that is allowed to be used. type AllowedFlexVolumeOutput struct{ *pulumi.OutputState } @@ -290,6 +351,12 @@ func (o AllowedFlexVolumeOutput) ToAllowedFlexVolumeOutputWithContext(ctx contex return o } +func (o AllowedFlexVolumeOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolume] { + return pulumix.Output[AllowedFlexVolume]{ + OutputState: o.OutputState, + } +} + // driver is the name of the Flexvolume driver. func (o AllowedFlexVolumeOutput) Driver() pulumi.StringOutput { return o.ApplyT(func(v AllowedFlexVolume) string { return v.Driver }).(pulumi.StringOutput) @@ -309,6 +376,12 @@ func (o AllowedFlexVolumeArrayOutput) ToAllowedFlexVolumeArrayOutputWithContext( return o } +func (o AllowedFlexVolumeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolume] { + return pulumix.Output[[]AllowedFlexVolume]{ + OutputState: o.OutputState, + } +} + func (o AllowedFlexVolumeArrayOutput) Index(i pulumi.IntInput) AllowedFlexVolumeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedFlexVolume { return vs[0].([]AllowedFlexVolume)[vs[1].(int)] @@ -350,6 +423,12 @@ func (i AllowedFlexVolumePatchArgs) ToAllowedFlexVolumePatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumePatchOutput) } +func (i AllowedFlexVolumePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolumePatch] { + return pulumix.Output[AllowedFlexVolumePatch]{ + OutputState: i.ToAllowedFlexVolumePatchOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolumePatchArrayInput is an input type that accepts AllowedFlexVolumePatchArray and AllowedFlexVolumePatchArrayOutput values. // You can construct a concrete instance of `AllowedFlexVolumePatchArrayInput` via: // @@ -375,6 +454,12 @@ func (i AllowedFlexVolumePatchArray) ToAllowedFlexVolumePatchArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(AllowedFlexVolumePatchArrayOutput) } +func (i AllowedFlexVolumePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolumePatch] { + return pulumix.Output[[]AllowedFlexVolumePatch]{ + OutputState: i.ToAllowedFlexVolumePatchArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedFlexVolume represents a single Flexvolume that is allowed to be used. type AllowedFlexVolumePatchOutput struct{ *pulumi.OutputState } @@ -390,6 +475,12 @@ func (o AllowedFlexVolumePatchOutput) ToAllowedFlexVolumePatchOutputWithContext( return o } +func (o AllowedFlexVolumePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedFlexVolumePatch] { + return pulumix.Output[AllowedFlexVolumePatch]{ + OutputState: o.OutputState, + } +} + // driver is the name of the Flexvolume driver. func (o AllowedFlexVolumePatchOutput) Driver() pulumi.StringPtrOutput { return o.ApplyT(func(v AllowedFlexVolumePatch) *string { return v.Driver }).(pulumi.StringPtrOutput) @@ -409,6 +500,12 @@ func (o AllowedFlexVolumePatchArrayOutput) ToAllowedFlexVolumePatchArrayOutputWi return o } +func (o AllowedFlexVolumePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedFlexVolumePatch] { + return pulumix.Output[[]AllowedFlexVolumePatch]{ + OutputState: o.OutputState, + } +} + func (o AllowedFlexVolumePatchArrayOutput) Index(i pulumi.IntInput) AllowedFlexVolumePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedFlexVolumePatch { return vs[0].([]AllowedFlexVolumePatch)[vs[1].(int)] @@ -458,6 +555,12 @@ func (i AllowedHostPathArgs) ToAllowedHostPathOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathOutput) } +func (i AllowedHostPathArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPath] { + return pulumix.Output[AllowedHostPath]{ + OutputState: i.ToAllowedHostPathOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPathArrayInput is an input type that accepts AllowedHostPathArray and AllowedHostPathArrayOutput values. // You can construct a concrete instance of `AllowedHostPathArrayInput` via: // @@ -483,6 +586,12 @@ func (i AllowedHostPathArray) ToAllowedHostPathArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathArrayOutput) } +func (i AllowedHostPathArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPath] { + return pulumix.Output[[]AllowedHostPath]{ + OutputState: i.ToAllowedHostPathArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. type AllowedHostPathOutput struct{ *pulumi.OutputState } @@ -498,6 +607,12 @@ func (o AllowedHostPathOutput) ToAllowedHostPathOutputWithContext(ctx context.Co return o } +func (o AllowedHostPathOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPath] { + return pulumix.Output[AllowedHostPath]{ + OutputState: o.OutputState, + } +} + // pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. // // Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` @@ -524,6 +639,12 @@ func (o AllowedHostPathArrayOutput) ToAllowedHostPathArrayOutputWithContext(ctx return o } +func (o AllowedHostPathArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPath] { + return pulumix.Output[[]AllowedHostPath]{ + OutputState: o.OutputState, + } +} + func (o AllowedHostPathArrayOutput) Index(i pulumi.IntInput) AllowedHostPathOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedHostPath { return vs[0].([]AllowedHostPath)[vs[1].(int)] @@ -573,6 +694,12 @@ func (i AllowedHostPathPatchArgs) ToAllowedHostPathPatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathPatchOutput) } +func (i AllowedHostPathPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPathPatch] { + return pulumix.Output[AllowedHostPathPatch]{ + OutputState: i.ToAllowedHostPathPatchOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPathPatchArrayInput is an input type that accepts AllowedHostPathPatchArray and AllowedHostPathPatchArrayOutput values. // You can construct a concrete instance of `AllowedHostPathPatchArrayInput` via: // @@ -598,6 +725,12 @@ func (i AllowedHostPathPatchArray) ToAllowedHostPathPatchArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(AllowedHostPathPatchArrayOutput) } +func (i AllowedHostPathPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPathPatch] { + return pulumix.Output[[]AllowedHostPathPatch]{ + OutputState: i.ToAllowedHostPathPatchArrayOutputWithContext(ctx).OutputState, + } +} + // AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. type AllowedHostPathPatchOutput struct{ *pulumi.OutputState } @@ -613,6 +746,12 @@ func (o AllowedHostPathPatchOutput) ToAllowedHostPathPatchOutputWithContext(ctx return o } +func (o AllowedHostPathPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllowedHostPathPatch] { + return pulumix.Output[AllowedHostPathPatch]{ + OutputState: o.OutputState, + } +} + // pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. // // Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` @@ -639,6 +778,12 @@ func (o AllowedHostPathPatchArrayOutput) ToAllowedHostPathPatchArrayOutputWithCo return o } +func (o AllowedHostPathPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AllowedHostPathPatch] { + return pulumix.Output[[]AllowedHostPathPatch]{ + OutputState: o.OutputState, + } +} + func (o AllowedHostPathPatchArrayOutput) Index(i pulumi.IntInput) AllowedHostPathPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) AllowedHostPathPatch { return vs[0].([]AllowedHostPathPatch)[vs[1].(int)] @@ -692,6 +837,12 @@ func (i EvictionArgs) ToEvictionOutputWithContext(ctx context.Context) EvictionO return pulumi.ToOutputWithContext(ctx, i).(EvictionOutput) } +func (i EvictionArgs) ToOutput(ctx context.Context) pulumix.Output[Eviction] { + return pulumix.Output[Eviction]{ + OutputState: i.ToEvictionOutputWithContext(ctx).OutputState, + } +} + // Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions. type EvictionOutput struct{ *pulumi.OutputState } @@ -707,6 +858,12 @@ func (o EvictionOutput) ToEvictionOutputWithContext(ctx context.Context) Evictio return o } +func (o EvictionOutput) ToOutput(ctx context.Context) pulumix.Output[Eviction] { + return pulumix.Output[Eviction]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EvictionOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Eviction) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -774,6 +931,12 @@ func (i EvictionPatchArgs) ToEvictionPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(EvictionPatchOutput) } +func (i EvictionPatchArgs) ToOutput(ctx context.Context) pulumix.Output[EvictionPatch] { + return pulumix.Output[EvictionPatch]{ + OutputState: i.ToEvictionPatchOutputWithContext(ctx).OutputState, + } +} + // Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions. type EvictionPatchOutput struct{ *pulumi.OutputState } @@ -789,6 +952,12 @@ func (o EvictionPatchOutput) ToEvictionPatchOutputWithContext(ctx context.Contex return o } +func (o EvictionPatchOutput) ToOutput(ctx context.Context) pulumix.Output[EvictionPatch] { + return pulumix.Output[EvictionPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o EvictionPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v EvictionPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -848,6 +1017,12 @@ func (i FSGroupStrategyOptionsArgs) ToFSGroupStrategyOptionsOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsOutput) } +func (i FSGroupStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptions] { + return pulumix.Output[FSGroupStrategyOptions]{ + OutputState: i.ToFSGroupStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i FSGroupStrategyOptionsArgs) ToFSGroupStrategyOptionsPtrOutput() FSGroupStrategyOptionsPtrOutput { return i.ToFSGroupStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -889,6 +1064,12 @@ func (i *fsgroupStrategyOptionsPtrType) ToFSGroupStrategyOptionsPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsPtrOutput) } +func (i *fsgroupStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptions] { + return pulumix.Output[*FSGroupStrategyOptions]{ + OutputState: i.ToFSGroupStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // FSGroupStrategyOptions defines the strategy type and options used to create the strategy. type FSGroupStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -914,6 +1095,12 @@ func (o FSGroupStrategyOptionsOutput) ToFSGroupStrategyOptionsPtrOutputWithConte }).(FSGroupStrategyOptionsPtrOutput) } +func (o FSGroupStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptions] { + return pulumix.Output[FSGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. func (o FSGroupStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v FSGroupStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -938,6 +1125,12 @@ func (o FSGroupStrategyOptionsPtrOutput) ToFSGroupStrategyOptionsPtrOutputWithCo return o } +func (o FSGroupStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptions] { + return pulumix.Output[*FSGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o FSGroupStrategyOptionsPtrOutput) Elem() FSGroupStrategyOptionsOutput { return o.ApplyT(func(v *FSGroupStrategyOptions) FSGroupStrategyOptions { if v != nil { @@ -1007,6 +1200,12 @@ func (i FSGroupStrategyOptionsPatchArgs) ToFSGroupStrategyOptionsPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsPatchOutput) } +func (i FSGroupStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptionsPatch] { + return pulumix.Output[FSGroupStrategyOptionsPatch]{ + OutputState: i.ToFSGroupStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i FSGroupStrategyOptionsPatchArgs) ToFSGroupStrategyOptionsPatchPtrOutput() FSGroupStrategyOptionsPatchPtrOutput { return i.ToFSGroupStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -1048,6 +1247,12 @@ func (i *fsgroupStrategyOptionsPatchPtrType) ToFSGroupStrategyOptionsPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(FSGroupStrategyOptionsPatchPtrOutput) } +func (i *fsgroupStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptionsPatch] { + return pulumix.Output[*FSGroupStrategyOptionsPatch]{ + OutputState: i.ToFSGroupStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // FSGroupStrategyOptions defines the strategy type and options used to create the strategy. type FSGroupStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -1073,6 +1278,12 @@ func (o FSGroupStrategyOptionsPatchOutput) ToFSGroupStrategyOptionsPatchPtrOutpu }).(FSGroupStrategyOptionsPatchPtrOutput) } +func (o FSGroupStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[FSGroupStrategyOptionsPatch] { + return pulumix.Output[FSGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. func (o FSGroupStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v FSGroupStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -1097,6 +1308,12 @@ func (o FSGroupStrategyOptionsPatchPtrOutput) ToFSGroupStrategyOptionsPatchPtrOu return o } +func (o FSGroupStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*FSGroupStrategyOptionsPatch] { + return pulumix.Output[*FSGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o FSGroupStrategyOptionsPatchPtrOutput) Elem() FSGroupStrategyOptionsPatchOutput { return o.ApplyT(func(v *FSGroupStrategyOptionsPatch) FSGroupStrategyOptionsPatch { if v != nil { @@ -1166,6 +1383,12 @@ func (i HostPortRangeArgs) ToHostPortRangeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(HostPortRangeOutput) } +func (i HostPortRangeArgs) ToOutput(ctx context.Context) pulumix.Output[HostPortRange] { + return pulumix.Output[HostPortRange]{ + OutputState: i.ToHostPortRangeOutputWithContext(ctx).OutputState, + } +} + // HostPortRangeArrayInput is an input type that accepts HostPortRangeArray and HostPortRangeArrayOutput values. // You can construct a concrete instance of `HostPortRangeArrayInput` via: // @@ -1191,6 +1414,12 @@ func (i HostPortRangeArray) ToHostPortRangeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(HostPortRangeArrayOutput) } +func (i HostPortRangeArray) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRange] { + return pulumix.Output[[]HostPortRange]{ + OutputState: i.ToHostPortRangeArrayOutputWithContext(ctx).OutputState, + } +} + // HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. type HostPortRangeOutput struct{ *pulumi.OutputState } @@ -1206,6 +1435,12 @@ func (o HostPortRangeOutput) ToHostPortRangeOutputWithContext(ctx context.Contex return o } +func (o HostPortRangeOutput) ToOutput(ctx context.Context) pulumix.Output[HostPortRange] { + return pulumix.Output[HostPortRange]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o HostPortRangeOutput) Max() pulumi.IntOutput { return o.ApplyT(func(v HostPortRange) int { return v.Max }).(pulumi.IntOutput) @@ -1230,6 +1465,12 @@ func (o HostPortRangeArrayOutput) ToHostPortRangeArrayOutputWithContext(ctx cont return o } +func (o HostPortRangeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRange] { + return pulumix.Output[[]HostPortRange]{ + OutputState: o.OutputState, + } +} + func (o HostPortRangeArrayOutput) Index(i pulumi.IntInput) HostPortRangeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostPortRange { return vs[0].([]HostPortRange)[vs[1].(int)] @@ -1275,6 +1516,12 @@ func (i HostPortRangePatchArgs) ToHostPortRangePatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(HostPortRangePatchOutput) } +func (i HostPortRangePatchArgs) ToOutput(ctx context.Context) pulumix.Output[HostPortRangePatch] { + return pulumix.Output[HostPortRangePatch]{ + OutputState: i.ToHostPortRangePatchOutputWithContext(ctx).OutputState, + } +} + // HostPortRangePatchArrayInput is an input type that accepts HostPortRangePatchArray and HostPortRangePatchArrayOutput values. // You can construct a concrete instance of `HostPortRangePatchArrayInput` via: // @@ -1300,6 +1547,12 @@ func (i HostPortRangePatchArray) ToHostPortRangePatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(HostPortRangePatchArrayOutput) } +func (i HostPortRangePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRangePatch] { + return pulumix.Output[[]HostPortRangePatch]{ + OutputState: i.ToHostPortRangePatchArrayOutputWithContext(ctx).OutputState, + } +} + // HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. type HostPortRangePatchOutput struct{ *pulumi.OutputState } @@ -1315,6 +1568,12 @@ func (o HostPortRangePatchOutput) ToHostPortRangePatchOutputWithContext(ctx cont return o } +func (o HostPortRangePatchOutput) ToOutput(ctx context.Context) pulumix.Output[HostPortRangePatch] { + return pulumix.Output[HostPortRangePatch]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o HostPortRangePatchOutput) Max() pulumi.IntPtrOutput { return o.ApplyT(func(v HostPortRangePatch) *int { return v.Max }).(pulumi.IntPtrOutput) @@ -1339,6 +1598,12 @@ func (o HostPortRangePatchArrayOutput) ToHostPortRangePatchArrayOutputWithContex return o } +func (o HostPortRangePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]HostPortRangePatch] { + return pulumix.Output[[]HostPortRangePatch]{ + OutputState: o.OutputState, + } +} + func (o HostPortRangePatchArrayOutput) Index(i pulumi.IntInput) HostPortRangePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) HostPortRangePatch { return vs[0].([]HostPortRangePatch)[vs[1].(int)] @@ -1384,6 +1649,12 @@ func (i IDRangeArgs) ToIDRangeOutputWithContext(ctx context.Context) IDRangeOutp return pulumi.ToOutputWithContext(ctx, i).(IDRangeOutput) } +func (i IDRangeArgs) ToOutput(ctx context.Context) pulumix.Output[IDRange] { + return pulumix.Output[IDRange]{ + OutputState: i.ToIDRangeOutputWithContext(ctx).OutputState, + } +} + // IDRangeArrayInput is an input type that accepts IDRangeArray and IDRangeArrayOutput values. // You can construct a concrete instance of `IDRangeArrayInput` via: // @@ -1409,6 +1680,12 @@ func (i IDRangeArray) ToIDRangeArrayOutputWithContext(ctx context.Context) IDRan return pulumi.ToOutputWithContext(ctx, i).(IDRangeArrayOutput) } +func (i IDRangeArray) ToOutput(ctx context.Context) pulumix.Output[[]IDRange] { + return pulumix.Output[[]IDRange]{ + OutputState: i.ToIDRangeArrayOutputWithContext(ctx).OutputState, + } +} + // IDRange provides a min/max of an allowed range of IDs. type IDRangeOutput struct{ *pulumi.OutputState } @@ -1424,6 +1701,12 @@ func (o IDRangeOutput) ToIDRangeOutputWithContext(ctx context.Context) IDRangeOu return o } +func (o IDRangeOutput) ToOutput(ctx context.Context) pulumix.Output[IDRange] { + return pulumix.Output[IDRange]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o IDRangeOutput) Max() pulumi.IntOutput { return o.ApplyT(func(v IDRange) int { return v.Max }).(pulumi.IntOutput) @@ -1448,6 +1731,12 @@ func (o IDRangeArrayOutput) ToIDRangeArrayOutputWithContext(ctx context.Context) return o } +func (o IDRangeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IDRange] { + return pulumix.Output[[]IDRange]{ + OutputState: o.OutputState, + } +} + func (o IDRangeArrayOutput) Index(i pulumi.IntInput) IDRangeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IDRange { return vs[0].([]IDRange)[vs[1].(int)] @@ -1493,6 +1782,12 @@ func (i IDRangePatchArgs) ToIDRangePatchOutputWithContext(ctx context.Context) I return pulumi.ToOutputWithContext(ctx, i).(IDRangePatchOutput) } +func (i IDRangePatchArgs) ToOutput(ctx context.Context) pulumix.Output[IDRangePatch] { + return pulumix.Output[IDRangePatch]{ + OutputState: i.ToIDRangePatchOutputWithContext(ctx).OutputState, + } +} + // IDRangePatchArrayInput is an input type that accepts IDRangePatchArray and IDRangePatchArrayOutput values. // You can construct a concrete instance of `IDRangePatchArrayInput` via: // @@ -1518,6 +1813,12 @@ func (i IDRangePatchArray) ToIDRangePatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(IDRangePatchArrayOutput) } +func (i IDRangePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]IDRangePatch] { + return pulumix.Output[[]IDRangePatch]{ + OutputState: i.ToIDRangePatchArrayOutputWithContext(ctx).OutputState, + } +} + // IDRange provides a min/max of an allowed range of IDs. type IDRangePatchOutput struct{ *pulumi.OutputState } @@ -1533,6 +1834,12 @@ func (o IDRangePatchOutput) ToIDRangePatchOutputWithContext(ctx context.Context) return o } +func (o IDRangePatchOutput) ToOutput(ctx context.Context) pulumix.Output[IDRangePatch] { + return pulumix.Output[IDRangePatch]{ + OutputState: o.OutputState, + } +} + // max is the end of the range, inclusive. func (o IDRangePatchOutput) Max() pulumi.IntPtrOutput { return o.ApplyT(func(v IDRangePatch) *int { return v.Max }).(pulumi.IntPtrOutput) @@ -1557,6 +1864,12 @@ func (o IDRangePatchArrayOutput) ToIDRangePatchArrayOutputWithContext(ctx contex return o } +func (o IDRangePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IDRangePatch] { + return pulumix.Output[[]IDRangePatch]{ + OutputState: o.OutputState, + } +} + func (o IDRangePatchArrayOutput) Index(i pulumi.IntInput) IDRangePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) IDRangePatch { return vs[0].([]IDRangePatch)[vs[1].(int)] @@ -1612,6 +1925,12 @@ func (i PodDisruptionBudgetTypeArgs) ToPodDisruptionBudgetTypeOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetTypeOutput) } +func (i PodDisruptionBudgetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetType] { + return pulumix.Output[PodDisruptionBudgetType]{ + OutputState: i.ToPodDisruptionBudgetTypeOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetTypeArrayInput is an input type that accepts PodDisruptionBudgetTypeArray and PodDisruptionBudgetTypeArrayOutput values. // You can construct a concrete instance of `PodDisruptionBudgetTypeArrayInput` via: // @@ -1637,6 +1956,12 @@ func (i PodDisruptionBudgetTypeArray) ToPodDisruptionBudgetTypeArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetTypeArrayOutput) } +func (i PodDisruptionBudgetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodDisruptionBudgetType] { + return pulumix.Output[[]PodDisruptionBudgetType]{ + OutputState: i.ToPodDisruptionBudgetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods type PodDisruptionBudgetTypeOutput struct{ *pulumi.OutputState } @@ -1652,6 +1977,12 @@ func (o PodDisruptionBudgetTypeOutput) ToPodDisruptionBudgetTypeOutputWithContex return o } +func (o PodDisruptionBudgetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetType] { + return pulumix.Output[PodDisruptionBudgetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1690,6 +2021,12 @@ func (o PodDisruptionBudgetTypeArrayOutput) ToPodDisruptionBudgetTypeArrayOutput return o } +func (o PodDisruptionBudgetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodDisruptionBudgetType] { + return pulumix.Output[[]PodDisruptionBudgetType]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetTypeArrayOutput) Index(i pulumi.IntInput) PodDisruptionBudgetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodDisruptionBudgetType { return vs[0].([]PodDisruptionBudgetType)[vs[1].(int)] @@ -1739,6 +2076,12 @@ func (i PodDisruptionBudgetListTypeArgs) ToPodDisruptionBudgetListTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetListTypeOutput) } +func (i PodDisruptionBudgetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetListType] { + return pulumix.Output[PodDisruptionBudgetListType]{ + OutputState: i.ToPodDisruptionBudgetListTypeOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetList is a collection of PodDisruptionBudgets. type PodDisruptionBudgetListTypeOutput struct{ *pulumi.OutputState } @@ -1754,6 +2097,12 @@ func (o PodDisruptionBudgetListTypeOutput) ToPodDisruptionBudgetListTypeOutputWi return o } +func (o PodDisruptionBudgetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetListType] { + return pulumix.Output[PodDisruptionBudgetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1821,6 +2170,12 @@ func (i PodDisruptionBudgetPatchTypeArgs) ToPodDisruptionBudgetPatchTypeOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetPatchTypeOutput) } +func (i PodDisruptionBudgetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetPatchType] { + return pulumix.Output[PodDisruptionBudgetPatchType]{ + OutputState: i.ToPodDisruptionBudgetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods type PodDisruptionBudgetPatchTypeOutput struct{ *pulumi.OutputState } @@ -1836,6 +2191,12 @@ func (o PodDisruptionBudgetPatchTypeOutput) ToPodDisruptionBudgetPatchTypeOutput return o } +func (o PodDisruptionBudgetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetPatchType] { + return pulumix.Output[PodDisruptionBudgetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodDisruptionBudgetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1903,6 +2264,12 @@ func (i PodDisruptionBudgetSpecArgs) ToPodDisruptionBudgetSpecOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecOutput) } +func (i PodDisruptionBudgetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpec] { + return pulumix.Output[PodDisruptionBudgetSpec]{ + OutputState: i.ToPodDisruptionBudgetSpecOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetSpecArgs) ToPodDisruptionBudgetSpecPtrOutput() PodDisruptionBudgetSpecPtrOutput { return i.ToPodDisruptionBudgetSpecPtrOutputWithContext(context.Background()) } @@ -1944,6 +2311,12 @@ func (i *podDisruptionBudgetSpecPtrType) ToPodDisruptionBudgetSpecPtrOutputWithC return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecPtrOutput) } +func (i *podDisruptionBudgetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpec] { + return pulumix.Output[*PodDisruptionBudgetSpec]{ + OutputState: i.ToPodDisruptionBudgetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetSpec is a description of a PodDisruptionBudget. type PodDisruptionBudgetSpecOutput struct{ *pulumi.OutputState } @@ -1969,6 +2342,12 @@ func (o PodDisruptionBudgetSpecOutput) ToPodDisruptionBudgetSpecPtrOutputWithCon }).(PodDisruptionBudgetSpecPtrOutput) } +func (o PodDisruptionBudgetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpec] { + return pulumix.Output[PodDisruptionBudgetSpec]{ + OutputState: o.OutputState, + } +} + // An eviction is allowed if at most "maxUnavailable" pods selected by "selector" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with "minAvailable". func (o PodDisruptionBudgetSpecOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v PodDisruptionBudgetSpec) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -1998,6 +2377,12 @@ func (o PodDisruptionBudgetSpecPtrOutput) ToPodDisruptionBudgetSpecPtrOutputWith return o } +func (o PodDisruptionBudgetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpec] { + return pulumix.Output[*PodDisruptionBudgetSpec]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetSpecPtrOutput) Elem() PodDisruptionBudgetSpecOutput { return o.ApplyT(func(v *PodDisruptionBudgetSpec) PodDisruptionBudgetSpec { if v != nil { @@ -2081,6 +2466,12 @@ func (i PodDisruptionBudgetSpecPatchArgs) ToPodDisruptionBudgetSpecPatchOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecPatchOutput) } +func (i PodDisruptionBudgetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpecPatch] { + return pulumix.Output[PodDisruptionBudgetSpecPatch]{ + OutputState: i.ToPodDisruptionBudgetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetSpecPatchArgs) ToPodDisruptionBudgetSpecPatchPtrOutput() PodDisruptionBudgetSpecPatchPtrOutput { return i.ToPodDisruptionBudgetSpecPatchPtrOutputWithContext(context.Background()) } @@ -2122,6 +2513,12 @@ func (i *podDisruptionBudgetSpecPatchPtrType) ToPodDisruptionBudgetSpecPatchPtrO return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetSpecPatchPtrOutput) } +func (i *podDisruptionBudgetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpecPatch] { + return pulumix.Output[*PodDisruptionBudgetSpecPatch]{ + OutputState: i.ToPodDisruptionBudgetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetSpec is a description of a PodDisruptionBudget. type PodDisruptionBudgetSpecPatchOutput struct{ *pulumi.OutputState } @@ -2147,6 +2544,12 @@ func (o PodDisruptionBudgetSpecPatchOutput) ToPodDisruptionBudgetSpecPatchPtrOut }).(PodDisruptionBudgetSpecPatchPtrOutput) } +func (o PodDisruptionBudgetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetSpecPatch] { + return pulumix.Output[PodDisruptionBudgetSpecPatch]{ + OutputState: o.OutputState, + } +} + // An eviction is allowed if at most "maxUnavailable" pods selected by "selector" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with "minAvailable". func (o PodDisruptionBudgetSpecPatchOutput) MaxUnavailable() pulumi.AnyOutput { return o.ApplyT(func(v PodDisruptionBudgetSpecPatch) interface{} { return v.MaxUnavailable }).(pulumi.AnyOutput) @@ -2176,6 +2579,12 @@ func (o PodDisruptionBudgetSpecPatchPtrOutput) ToPodDisruptionBudgetSpecPatchPtr return o } +func (o PodDisruptionBudgetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetSpecPatch] { + return pulumix.Output[*PodDisruptionBudgetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetSpecPatchPtrOutput) Elem() PodDisruptionBudgetSpecPatchOutput { return o.ApplyT(func(v *PodDisruptionBudgetSpecPatch) PodDisruptionBudgetSpecPatch { if v != nil { @@ -2271,6 +2680,12 @@ func (i PodDisruptionBudgetStatusArgs) ToPodDisruptionBudgetStatusOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusOutput) } +func (i PodDisruptionBudgetStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatus] { + return pulumix.Output[PodDisruptionBudgetStatus]{ + OutputState: i.ToPodDisruptionBudgetStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetStatusArgs) ToPodDisruptionBudgetStatusPtrOutput() PodDisruptionBudgetStatusPtrOutput { return i.ToPodDisruptionBudgetStatusPtrOutputWithContext(context.Background()) } @@ -2312,6 +2727,12 @@ func (i *podDisruptionBudgetStatusPtrType) ToPodDisruptionBudgetStatusPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusPtrOutput) } +func (i *podDisruptionBudgetStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatus] { + return pulumix.Output[*PodDisruptionBudgetStatus]{ + OutputState: i.ToPodDisruptionBudgetStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system. type PodDisruptionBudgetStatusOutput struct{ *pulumi.OutputState } @@ -2337,6 +2758,12 @@ func (o PodDisruptionBudgetStatusOutput) ToPodDisruptionBudgetStatusPtrOutputWit }).(PodDisruptionBudgetStatusPtrOutput) } +func (o PodDisruptionBudgetStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatus] { + return pulumix.Output[PodDisruptionBudgetStatus]{ + OutputState: o.OutputState, + } +} + // current number of healthy pods func (o PodDisruptionBudgetStatusOutput) CurrentHealthy() pulumi.IntOutput { return o.ApplyT(func(v PodDisruptionBudgetStatus) int { return v.CurrentHealthy }).(pulumi.IntOutput) @@ -2381,6 +2808,12 @@ func (o PodDisruptionBudgetStatusPtrOutput) ToPodDisruptionBudgetStatusPtrOutput return o } +func (o PodDisruptionBudgetStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatus] { + return pulumix.Output[*PodDisruptionBudgetStatus]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetStatusPtrOutput) Elem() PodDisruptionBudgetStatusOutput { return o.ApplyT(func(v *PodDisruptionBudgetStatus) PodDisruptionBudgetStatus { if v != nil { @@ -2506,6 +2939,12 @@ func (i PodDisruptionBudgetStatusPatchArgs) ToPodDisruptionBudgetStatusPatchOutp return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusPatchOutput) } +func (i PodDisruptionBudgetStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatusPatch] { + return pulumix.Output[PodDisruptionBudgetStatusPatch]{ + OutputState: i.ToPodDisruptionBudgetStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodDisruptionBudgetStatusPatchArgs) ToPodDisruptionBudgetStatusPatchPtrOutput() PodDisruptionBudgetStatusPatchPtrOutput { return i.ToPodDisruptionBudgetStatusPatchPtrOutputWithContext(context.Background()) } @@ -2547,6 +2986,12 @@ func (i *podDisruptionBudgetStatusPatchPtrType) ToPodDisruptionBudgetStatusPatch return pulumi.ToOutputWithContext(ctx, i).(PodDisruptionBudgetStatusPatchPtrOutput) } +func (i *podDisruptionBudgetStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatusPatch] { + return pulumix.Output[*PodDisruptionBudgetStatusPatch]{ + OutputState: i.ToPodDisruptionBudgetStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system. type PodDisruptionBudgetStatusPatchOutput struct{ *pulumi.OutputState } @@ -2572,6 +3017,12 @@ func (o PodDisruptionBudgetStatusPatchOutput) ToPodDisruptionBudgetStatusPatchPt }).(PodDisruptionBudgetStatusPatchPtrOutput) } +func (o PodDisruptionBudgetStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodDisruptionBudgetStatusPatch] { + return pulumix.Output[PodDisruptionBudgetStatusPatch]{ + OutputState: o.OutputState, + } +} + // current number of healthy pods func (o PodDisruptionBudgetStatusPatchOutput) CurrentHealthy() pulumi.IntPtrOutput { return o.ApplyT(func(v PodDisruptionBudgetStatusPatch) *int { return v.CurrentHealthy }).(pulumi.IntPtrOutput) @@ -2616,6 +3067,12 @@ func (o PodDisruptionBudgetStatusPatchPtrOutput) ToPodDisruptionBudgetStatusPatc return o } +func (o PodDisruptionBudgetStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodDisruptionBudgetStatusPatch] { + return pulumix.Output[*PodDisruptionBudgetStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodDisruptionBudgetStatusPatchPtrOutput) Elem() PodDisruptionBudgetStatusPatchOutput { return o.ApplyT(func(v *PodDisruptionBudgetStatusPatch) PodDisruptionBudgetStatusPatch { if v != nil { @@ -2733,6 +3190,12 @@ func (i PodSecurityPolicyTypeArgs) ToPodSecurityPolicyTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyTypeOutput) } +func (i PodSecurityPolicyTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyType] { + return pulumix.Output[PodSecurityPolicyType]{ + OutputState: i.ToPodSecurityPolicyTypeOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyTypeArrayInput is an input type that accepts PodSecurityPolicyTypeArray and PodSecurityPolicyTypeArrayOutput values. // You can construct a concrete instance of `PodSecurityPolicyTypeArrayInput` via: // @@ -2758,6 +3221,12 @@ func (i PodSecurityPolicyTypeArray) ToPodSecurityPolicyTypeArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyTypeArrayOutput) } +func (i PodSecurityPolicyTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodSecurityPolicyType] { + return pulumix.Output[[]PodSecurityPolicyType]{ + OutputState: i.ToPodSecurityPolicyTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. type PodSecurityPolicyTypeOutput struct{ *pulumi.OutputState } @@ -2773,6 +3242,12 @@ func (o PodSecurityPolicyTypeOutput) ToPodSecurityPolicyTypeOutputWithContext(ct return o } +func (o PodSecurityPolicyTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyType] { + return pulumix.Output[PodSecurityPolicyType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSecurityPolicyType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2807,6 +3282,12 @@ func (o PodSecurityPolicyTypeArrayOutput) ToPodSecurityPolicyTypeArrayOutputWith return o } +func (o PodSecurityPolicyTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodSecurityPolicyType] { + return pulumix.Output[[]PodSecurityPolicyType]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicyTypeArrayOutput) Index(i pulumi.IntInput) PodSecurityPolicyTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodSecurityPolicyType { return vs[0].([]PodSecurityPolicyType)[vs[1].(int)] @@ -2860,6 +3341,12 @@ func (i PodSecurityPolicyListTypeArgs) ToPodSecurityPolicyListTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyListTypeOutput) } +func (i PodSecurityPolicyListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyListType] { + return pulumix.Output[PodSecurityPolicyListType]{ + OutputState: i.ToPodSecurityPolicyListTypeOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicyList is a list of PodSecurityPolicy objects. type PodSecurityPolicyListTypeOutput struct{ *pulumi.OutputState } @@ -2875,6 +3362,12 @@ func (o PodSecurityPolicyListTypeOutput) ToPodSecurityPolicyListTypeOutputWithCo return o } +func (o PodSecurityPolicyListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyListType] { + return pulumix.Output[PodSecurityPolicyListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSecurityPolicyListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2942,6 +3435,12 @@ func (i PodSecurityPolicyPatchTypeArgs) ToPodSecurityPolicyPatchTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicyPatchTypeOutput) } +func (i PodSecurityPolicyPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyPatchType] { + return pulumix.Output[PodSecurityPolicyPatchType]{ + OutputState: i.ToPodSecurityPolicyPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. type PodSecurityPolicyPatchTypeOutput struct{ *pulumi.OutputState } @@ -2957,6 +3456,12 @@ func (o PodSecurityPolicyPatchTypeOutput) ToPodSecurityPolicyPatchTypeOutputWith return o } +func (o PodSecurityPolicyPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicyPatchType] { + return pulumix.Output[PodSecurityPolicyPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSecurityPolicyPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSecurityPolicyPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3112,6 +3617,12 @@ func (i PodSecurityPolicySpecArgs) ToPodSecurityPolicySpecOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecOutput) } +func (i PodSecurityPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpec] { + return pulumix.Output[PodSecurityPolicySpec]{ + OutputState: i.ToPodSecurityPolicySpecOutputWithContext(ctx).OutputState, + } +} + func (i PodSecurityPolicySpecArgs) ToPodSecurityPolicySpecPtrOutput() PodSecurityPolicySpecPtrOutput { return i.ToPodSecurityPolicySpecPtrOutputWithContext(context.Background()) } @@ -3153,6 +3664,12 @@ func (i *podSecurityPolicySpecPtrType) ToPodSecurityPolicySpecPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecPtrOutput) } +func (i *podSecurityPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpec] { + return pulumix.Output[*PodSecurityPolicySpec]{ + OutputState: i.ToPodSecurityPolicySpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicySpec defines the policy enforced. type PodSecurityPolicySpecOutput struct{ *pulumi.OutputState } @@ -3178,6 +3695,12 @@ func (o PodSecurityPolicySpecOutput) ToPodSecurityPolicySpecPtrOutputWithContext }).(PodSecurityPolicySpecPtrOutput) } +func (o PodSecurityPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpec] { + return pulumix.Output[PodSecurityPolicySpec]{ + OutputState: o.OutputState, + } +} + // allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. func (o PodSecurityPolicySpecOutput) AllowPrivilegeEscalation() pulumi.BoolPtrOutput { return o.ApplyT(func(v PodSecurityPolicySpec) *bool { return v.AllowPrivilegeEscalation }).(pulumi.BoolPtrOutput) @@ -3316,6 +3839,12 @@ func (o PodSecurityPolicySpecPtrOutput) ToPodSecurityPolicySpecPtrOutputWithCont return o } +func (o PodSecurityPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpec] { + return pulumix.Output[*PodSecurityPolicySpec]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicySpecPtrOutput) Elem() PodSecurityPolicySpecOutput { return o.ApplyT(func(v *PodSecurityPolicySpec) PodSecurityPolicySpec { if v != nil { @@ -3705,6 +4234,12 @@ func (i PodSecurityPolicySpecPatchArgs) ToPodSecurityPolicySpecPatchOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecPatchOutput) } +func (i PodSecurityPolicySpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpecPatch] { + return pulumix.Output[PodSecurityPolicySpecPatch]{ + OutputState: i.ToPodSecurityPolicySpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSecurityPolicySpecPatchArgs) ToPodSecurityPolicySpecPatchPtrOutput() PodSecurityPolicySpecPatchPtrOutput { return i.ToPodSecurityPolicySpecPatchPtrOutputWithContext(context.Background()) } @@ -3746,6 +4281,12 @@ func (i *podSecurityPolicySpecPatchPtrType) ToPodSecurityPolicySpecPatchPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(PodSecurityPolicySpecPatchPtrOutput) } +func (i *podSecurityPolicySpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpecPatch] { + return pulumix.Output[*PodSecurityPolicySpecPatch]{ + OutputState: i.ToPodSecurityPolicySpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSecurityPolicySpec defines the policy enforced. type PodSecurityPolicySpecPatchOutput struct{ *pulumi.OutputState } @@ -3771,6 +4312,12 @@ func (o PodSecurityPolicySpecPatchOutput) ToPodSecurityPolicySpecPatchPtrOutputW }).(PodSecurityPolicySpecPatchPtrOutput) } +func (o PodSecurityPolicySpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSecurityPolicySpecPatch] { + return pulumix.Output[PodSecurityPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + // allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. func (o PodSecurityPolicySpecPatchOutput) AllowPrivilegeEscalation() pulumi.BoolPtrOutput { return o.ApplyT(func(v PodSecurityPolicySpecPatch) *bool { return v.AllowPrivilegeEscalation }).(pulumi.BoolPtrOutput) @@ -3911,6 +4458,12 @@ func (o PodSecurityPolicySpecPatchPtrOutput) ToPodSecurityPolicySpecPatchPtrOutp return o } +func (o PodSecurityPolicySpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSecurityPolicySpecPatch] { + return pulumix.Output[*PodSecurityPolicySpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSecurityPolicySpecPatchPtrOutput) Elem() PodSecurityPolicySpecPatchOutput { return o.ApplyT(func(v *PodSecurityPolicySpecPatch) PodSecurityPolicySpecPatch { if v != nil { @@ -4204,6 +4757,12 @@ func (i RunAsGroupStrategyOptionsArgs) ToRunAsGroupStrategyOptionsOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsOutput) } +func (i RunAsGroupStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptions] { + return pulumix.Output[RunAsGroupStrategyOptions]{ + OutputState: i.ToRunAsGroupStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i RunAsGroupStrategyOptionsArgs) ToRunAsGroupStrategyOptionsPtrOutput() RunAsGroupStrategyOptionsPtrOutput { return i.ToRunAsGroupStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -4245,6 +4804,12 @@ func (i *runAsGroupStrategyOptionsPtrType) ToRunAsGroupStrategyOptionsPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsPtrOutput) } +func (i *runAsGroupStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptions] { + return pulumix.Output[*RunAsGroupStrategyOptions]{ + OutputState: i.ToRunAsGroupStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. type RunAsGroupStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -4270,6 +4835,12 @@ func (o RunAsGroupStrategyOptionsOutput) ToRunAsGroupStrategyOptionsPtrOutputWit }).(RunAsGroupStrategyOptionsPtrOutput) } +func (o RunAsGroupStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptions] { + return pulumix.Output[RunAsGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsGroupStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v RunAsGroupStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -4294,6 +4865,12 @@ func (o RunAsGroupStrategyOptionsPtrOutput) ToRunAsGroupStrategyOptionsPtrOutput return o } +func (o RunAsGroupStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptions] { + return pulumix.Output[*RunAsGroupStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o RunAsGroupStrategyOptionsPtrOutput) Elem() RunAsGroupStrategyOptionsOutput { return o.ApplyT(func(v *RunAsGroupStrategyOptions) RunAsGroupStrategyOptions { if v != nil { @@ -4363,6 +4940,12 @@ func (i RunAsGroupStrategyOptionsPatchArgs) ToRunAsGroupStrategyOptionsPatchOutp return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsPatchOutput) } +func (i RunAsGroupStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[RunAsGroupStrategyOptionsPatch]{ + OutputState: i.ToRunAsGroupStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i RunAsGroupStrategyOptionsPatchArgs) ToRunAsGroupStrategyOptionsPatchPtrOutput() RunAsGroupStrategyOptionsPatchPtrOutput { return i.ToRunAsGroupStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -4404,6 +4987,12 @@ func (i *runAsGroupStrategyOptionsPatchPtrType) ToRunAsGroupStrategyOptionsPatch return pulumi.ToOutputWithContext(ctx, i).(RunAsGroupStrategyOptionsPatchPtrOutput) } +func (i *runAsGroupStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[*RunAsGroupStrategyOptionsPatch]{ + OutputState: i.ToRunAsGroupStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. type RunAsGroupStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -4429,6 +5018,12 @@ func (o RunAsGroupStrategyOptionsPatchOutput) ToRunAsGroupStrategyOptionsPatchPt }).(RunAsGroupStrategyOptionsPatchPtrOutput) } +func (o RunAsGroupStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[RunAsGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsGroupStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v RunAsGroupStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -4453,6 +5048,12 @@ func (o RunAsGroupStrategyOptionsPatchPtrOutput) ToRunAsGroupStrategyOptionsPatc return o } +func (o RunAsGroupStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsGroupStrategyOptionsPatch] { + return pulumix.Output[*RunAsGroupStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o RunAsGroupStrategyOptionsPatchPtrOutput) Elem() RunAsGroupStrategyOptionsPatchOutput { return o.ApplyT(func(v *RunAsGroupStrategyOptionsPatch) RunAsGroupStrategyOptionsPatch { if v != nil { @@ -4522,6 +5123,12 @@ func (i RunAsUserStrategyOptionsArgs) ToRunAsUserStrategyOptionsOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsOutput) } +func (i RunAsUserStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptions] { + return pulumix.Output[RunAsUserStrategyOptions]{ + OutputState: i.ToRunAsUserStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i RunAsUserStrategyOptionsArgs) ToRunAsUserStrategyOptionsPtrOutput() RunAsUserStrategyOptionsPtrOutput { return i.ToRunAsUserStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -4563,6 +5170,12 @@ func (i *runAsUserStrategyOptionsPtrType) ToRunAsUserStrategyOptionsPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsPtrOutput) } +func (i *runAsUserStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptions] { + return pulumix.Output[*RunAsUserStrategyOptions]{ + OutputState: i.ToRunAsUserStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. type RunAsUserStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -4588,6 +5201,12 @@ func (o RunAsUserStrategyOptionsOutput) ToRunAsUserStrategyOptionsPtrOutputWithC }).(RunAsUserStrategyOptionsPtrOutput) } +func (o RunAsUserStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptions] { + return pulumix.Output[RunAsUserStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsUserStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v RunAsUserStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -4612,6 +5231,12 @@ func (o RunAsUserStrategyOptionsPtrOutput) ToRunAsUserStrategyOptionsPtrOutputWi return o } +func (o RunAsUserStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptions] { + return pulumix.Output[*RunAsUserStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o RunAsUserStrategyOptionsPtrOutput) Elem() RunAsUserStrategyOptionsOutput { return o.ApplyT(func(v *RunAsUserStrategyOptions) RunAsUserStrategyOptions { if v != nil { @@ -4681,6 +5306,12 @@ func (i RunAsUserStrategyOptionsPatchArgs) ToRunAsUserStrategyOptionsPatchOutput return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsPatchOutput) } +func (i RunAsUserStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptionsPatch] { + return pulumix.Output[RunAsUserStrategyOptionsPatch]{ + OutputState: i.ToRunAsUserStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i RunAsUserStrategyOptionsPatchArgs) ToRunAsUserStrategyOptionsPatchPtrOutput() RunAsUserStrategyOptionsPatchPtrOutput { return i.ToRunAsUserStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -4722,6 +5353,12 @@ func (i *runAsUserStrategyOptionsPatchPtrType) ToRunAsUserStrategyOptionsPatchPt return pulumi.ToOutputWithContext(ctx, i).(RunAsUserStrategyOptionsPatchPtrOutput) } +func (i *runAsUserStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptionsPatch] { + return pulumix.Output[*RunAsUserStrategyOptionsPatch]{ + OutputState: i.ToRunAsUserStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. type RunAsUserStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -4747,6 +5384,12 @@ func (o RunAsUserStrategyOptionsPatchOutput) ToRunAsUserStrategyOptionsPatchPtrO }).(RunAsUserStrategyOptionsPatchPtrOutput) } +func (o RunAsUserStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RunAsUserStrategyOptionsPatch] { + return pulumix.Output[RunAsUserStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. func (o RunAsUserStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v RunAsUserStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -4771,6 +5414,12 @@ func (o RunAsUserStrategyOptionsPatchPtrOutput) ToRunAsUserStrategyOptionsPatchP return o } +func (o RunAsUserStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RunAsUserStrategyOptionsPatch] { + return pulumix.Output[*RunAsUserStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o RunAsUserStrategyOptionsPatchPtrOutput) Elem() RunAsUserStrategyOptionsPatchOutput { return o.ApplyT(func(v *RunAsUserStrategyOptionsPatch) RunAsUserStrategyOptionsPatch { if v != nil { @@ -4840,6 +5489,12 @@ func (i RuntimeClassStrategyOptionsArgs) ToRuntimeClassStrategyOptionsOutputWith return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsOutput) } +func (i RuntimeClassStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptions] { + return pulumix.Output[RuntimeClassStrategyOptions]{ + OutputState: i.ToRuntimeClassStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i RuntimeClassStrategyOptionsArgs) ToRuntimeClassStrategyOptionsPtrOutput() RuntimeClassStrategyOptionsPtrOutput { return i.ToRuntimeClassStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -4881,6 +5536,12 @@ func (i *runtimeClassStrategyOptionsPtrType) ToRuntimeClassStrategyOptionsPtrOut return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsPtrOutput) } +func (i *runtimeClassStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptions] { + return pulumix.Output[*RuntimeClassStrategyOptions]{ + OutputState: i.ToRuntimeClassStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod. type RuntimeClassStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -4906,6 +5567,12 @@ func (o RuntimeClassStrategyOptionsOutput) ToRuntimeClassStrategyOptionsPtrOutpu }).(RuntimeClassStrategyOptionsPtrOutput) } +func (o RuntimeClassStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptions] { + return pulumix.Output[RuntimeClassStrategyOptions]{ + OutputState: o.OutputState, + } +} + // allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. func (o RuntimeClassStrategyOptionsOutput) AllowedRuntimeClassNames() pulumi.StringArrayOutput { return o.ApplyT(func(v RuntimeClassStrategyOptions) []string { return v.AllowedRuntimeClassNames }).(pulumi.StringArrayOutput) @@ -4930,6 +5597,12 @@ func (o RuntimeClassStrategyOptionsPtrOutput) ToRuntimeClassStrategyOptionsPtrOu return o } +func (o RuntimeClassStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptions] { + return pulumix.Output[*RuntimeClassStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassStrategyOptionsPtrOutput) Elem() RuntimeClassStrategyOptionsOutput { return o.ApplyT(func(v *RuntimeClassStrategyOptions) RuntimeClassStrategyOptions { if v != nil { @@ -4999,6 +5672,12 @@ func (i RuntimeClassStrategyOptionsPatchArgs) ToRuntimeClassStrategyOptionsPatch return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsPatchOutput) } +func (i RuntimeClassStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[RuntimeClassStrategyOptionsPatch]{ + OutputState: i.ToRuntimeClassStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i RuntimeClassStrategyOptionsPatchArgs) ToRuntimeClassStrategyOptionsPatchPtrOutput() RuntimeClassStrategyOptionsPatchPtrOutput { return i.ToRuntimeClassStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -5040,6 +5719,12 @@ func (i *runtimeClassStrategyOptionsPatchPtrType) ToRuntimeClassStrategyOptionsP return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassStrategyOptionsPatchPtrOutput) } +func (i *runtimeClassStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[*RuntimeClassStrategyOptionsPatch]{ + OutputState: i.ToRuntimeClassStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod. type RuntimeClassStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -5065,6 +5750,12 @@ func (o RuntimeClassStrategyOptionsPatchOutput) ToRuntimeClassStrategyOptionsPat }).(RuntimeClassStrategyOptionsPatchPtrOutput) } +func (o RuntimeClassStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[RuntimeClassStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. func (o RuntimeClassStrategyOptionsPatchOutput) AllowedRuntimeClassNames() pulumi.StringArrayOutput { return o.ApplyT(func(v RuntimeClassStrategyOptionsPatch) []string { return v.AllowedRuntimeClassNames }).(pulumi.StringArrayOutput) @@ -5089,6 +5780,12 @@ func (o RuntimeClassStrategyOptionsPatchPtrOutput) ToRuntimeClassStrategyOptions return o } +func (o RuntimeClassStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RuntimeClassStrategyOptionsPatch] { + return pulumix.Output[*RuntimeClassStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o RuntimeClassStrategyOptionsPatchPtrOutput) Elem() RuntimeClassStrategyOptionsPatchOutput { return o.ApplyT(func(v *RuntimeClassStrategyOptionsPatch) RuntimeClassStrategyOptionsPatch { if v != nil { @@ -5158,6 +5855,12 @@ func (i SELinuxStrategyOptionsArgs) ToSELinuxStrategyOptionsOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsOutput) } +func (i SELinuxStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptions] { + return pulumix.Output[SELinuxStrategyOptions]{ + OutputState: i.ToSELinuxStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i SELinuxStrategyOptionsArgs) ToSELinuxStrategyOptionsPtrOutput() SELinuxStrategyOptionsPtrOutput { return i.ToSELinuxStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -5199,6 +5902,12 @@ func (i *selinuxStrategyOptionsPtrType) ToSELinuxStrategyOptionsPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsPtrOutput) } +func (i *selinuxStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptions] { + return pulumix.Output[*SELinuxStrategyOptions]{ + OutputState: i.ToSELinuxStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. type SELinuxStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -5224,6 +5933,12 @@ func (o SELinuxStrategyOptionsOutput) ToSELinuxStrategyOptionsPtrOutputWithConte }).(SELinuxStrategyOptionsPtrOutput) } +func (o SELinuxStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptions] { + return pulumix.Output[SELinuxStrategyOptions]{ + OutputState: o.OutputState, + } +} + // rule is the strategy that will dictate the allowable labels that may be set. func (o SELinuxStrategyOptionsOutput) Rule() pulumi.StringOutput { return o.ApplyT(func(v SELinuxStrategyOptions) string { return v.Rule }).(pulumi.StringOutput) @@ -5248,6 +5963,12 @@ func (o SELinuxStrategyOptionsPtrOutput) ToSELinuxStrategyOptionsPtrOutputWithCo return o } +func (o SELinuxStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptions] { + return pulumix.Output[*SELinuxStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o SELinuxStrategyOptionsPtrOutput) Elem() SELinuxStrategyOptionsOutput { return o.ApplyT(func(v *SELinuxStrategyOptions) SELinuxStrategyOptions { if v != nil { @@ -5317,6 +6038,12 @@ func (i SELinuxStrategyOptionsPatchArgs) ToSELinuxStrategyOptionsPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsPatchOutput) } +func (i SELinuxStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptionsPatch] { + return pulumix.Output[SELinuxStrategyOptionsPatch]{ + OutputState: i.ToSELinuxStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i SELinuxStrategyOptionsPatchArgs) ToSELinuxStrategyOptionsPatchPtrOutput() SELinuxStrategyOptionsPatchPtrOutput { return i.ToSELinuxStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -5358,6 +6085,12 @@ func (i *selinuxStrategyOptionsPatchPtrType) ToSELinuxStrategyOptionsPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(SELinuxStrategyOptionsPatchPtrOutput) } +func (i *selinuxStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptionsPatch] { + return pulumix.Output[*SELinuxStrategyOptionsPatch]{ + OutputState: i.ToSELinuxStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. type SELinuxStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -5383,6 +6116,12 @@ func (o SELinuxStrategyOptionsPatchOutput) ToSELinuxStrategyOptionsPatchPtrOutpu }).(SELinuxStrategyOptionsPatchPtrOutput) } +func (o SELinuxStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SELinuxStrategyOptionsPatch] { + return pulumix.Output[SELinuxStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // rule is the strategy that will dictate the allowable labels that may be set. func (o SELinuxStrategyOptionsPatchOutput) Rule() pulumi.StringPtrOutput { return o.ApplyT(func(v SELinuxStrategyOptionsPatch) *string { return v.Rule }).(pulumi.StringPtrOutput) @@ -5407,6 +6146,12 @@ func (o SELinuxStrategyOptionsPatchPtrOutput) ToSELinuxStrategyOptionsPatchPtrOu return o } +func (o SELinuxStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SELinuxStrategyOptionsPatch] { + return pulumix.Output[*SELinuxStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o SELinuxStrategyOptionsPatchPtrOutput) Elem() SELinuxStrategyOptionsPatchOutput { return o.ApplyT(func(v *SELinuxStrategyOptionsPatch) SELinuxStrategyOptionsPatch { if v != nil { @@ -5476,6 +6221,12 @@ func (i SupplementalGroupsStrategyOptionsArgs) ToSupplementalGroupsStrategyOptio return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsOutput) } +func (i SupplementalGroupsStrategyOptionsArgs) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptions] { + return pulumix.Output[SupplementalGroupsStrategyOptions]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsOutputWithContext(ctx).OutputState, + } +} + func (i SupplementalGroupsStrategyOptionsArgs) ToSupplementalGroupsStrategyOptionsPtrOutput() SupplementalGroupsStrategyOptionsPtrOutput { return i.ToSupplementalGroupsStrategyOptionsPtrOutputWithContext(context.Background()) } @@ -5517,6 +6268,12 @@ func (i *supplementalGroupsStrategyOptionsPtrType) ToSupplementalGroupsStrategyO return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsPtrOutput) } +func (i *supplementalGroupsStrategyOptionsPtrType) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptions] { + return pulumix.Output[*SupplementalGroupsStrategyOptions]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsPtrOutputWithContext(ctx).OutputState, + } +} + // SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. type SupplementalGroupsStrategyOptionsOutput struct{ *pulumi.OutputState } @@ -5542,6 +6299,12 @@ func (o SupplementalGroupsStrategyOptionsOutput) ToSupplementalGroupsStrategyOpt }).(SupplementalGroupsStrategyOptionsPtrOutput) } +func (o SupplementalGroupsStrategyOptionsOutput) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptions] { + return pulumix.Output[SupplementalGroupsStrategyOptions]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. func (o SupplementalGroupsStrategyOptionsOutput) Ranges() IDRangeArrayOutput { return o.ApplyT(func(v SupplementalGroupsStrategyOptions) []IDRange { return v.Ranges }).(IDRangeArrayOutput) @@ -5566,6 +6329,12 @@ func (o SupplementalGroupsStrategyOptionsPtrOutput) ToSupplementalGroupsStrategy return o } +func (o SupplementalGroupsStrategyOptionsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptions] { + return pulumix.Output[*SupplementalGroupsStrategyOptions]{ + OutputState: o.OutputState, + } +} + func (o SupplementalGroupsStrategyOptionsPtrOutput) Elem() SupplementalGroupsStrategyOptionsOutput { return o.ApplyT(func(v *SupplementalGroupsStrategyOptions) SupplementalGroupsStrategyOptions { if v != nil { @@ -5635,6 +6404,12 @@ func (i SupplementalGroupsStrategyOptionsPatchArgs) ToSupplementalGroupsStrategy return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsPatchOutput) } +func (i SupplementalGroupsStrategyOptionsPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[SupplementalGroupsStrategyOptionsPatch]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsPatchOutputWithContext(ctx).OutputState, + } +} + func (i SupplementalGroupsStrategyOptionsPatchArgs) ToSupplementalGroupsStrategyOptionsPatchPtrOutput() SupplementalGroupsStrategyOptionsPatchPtrOutput { return i.ToSupplementalGroupsStrategyOptionsPatchPtrOutputWithContext(context.Background()) } @@ -5676,6 +6451,12 @@ func (i *supplementalGroupsStrategyOptionsPatchPtrType) ToSupplementalGroupsStra return pulumi.ToOutputWithContext(ctx, i).(SupplementalGroupsStrategyOptionsPatchPtrOutput) } +func (i *supplementalGroupsStrategyOptionsPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[*SupplementalGroupsStrategyOptionsPatch]{ + OutputState: i.ToSupplementalGroupsStrategyOptionsPatchPtrOutputWithContext(ctx).OutputState, + } +} + // SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. type SupplementalGroupsStrategyOptionsPatchOutput struct{ *pulumi.OutputState } @@ -5701,6 +6482,12 @@ func (o SupplementalGroupsStrategyOptionsPatchOutput) ToSupplementalGroupsStrate }).(SupplementalGroupsStrategyOptionsPatchPtrOutput) } +func (o SupplementalGroupsStrategyOptionsPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[SupplementalGroupsStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + // ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. func (o SupplementalGroupsStrategyOptionsPatchOutput) Ranges() IDRangePatchArrayOutput { return o.ApplyT(func(v SupplementalGroupsStrategyOptionsPatch) []IDRangePatch { return v.Ranges }).(IDRangePatchArrayOutput) @@ -5725,6 +6512,12 @@ func (o SupplementalGroupsStrategyOptionsPatchPtrOutput) ToSupplementalGroupsStr return o } +func (o SupplementalGroupsStrategyOptionsPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*SupplementalGroupsStrategyOptionsPatch] { + return pulumix.Output[*SupplementalGroupsStrategyOptionsPatch]{ + OutputState: o.OutputState, + } +} + func (o SupplementalGroupsStrategyOptionsPatchPtrOutput) Elem() SupplementalGroupsStrategyOptionsPatchOutput { return o.ApplyT(func(v *SupplementalGroupsStrategyOptionsPatch) SupplementalGroupsStrategyOptionsPatch { if v != nil { diff --git a/sdk/go/kubernetes/provider.go b/sdk/go/kubernetes/provider.go index fdcfc3ae66..4d4c7ccee7 100644 --- a/sdk/go/kubernetes/provider.go +++ b/sdk/go/kubernetes/provider.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // The provider type for the kubernetes package. @@ -182,6 +183,12 @@ func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutp return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput) } +func (i *Provider) ToOutput(ctx context.Context) pulumix.Output[*Provider] { + return pulumix.Output[*Provider]{ + OutputState: i.ToProviderOutputWithContext(ctx).OutputState, + } +} + type ProviderOutput struct{ *pulumi.OutputState } func (ProviderOutput) ElementType() reflect.Type { @@ -196,6 +203,12 @@ func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) Provide return o } +func (o ProviderOutput) ToOutput(ctx context.Context) pulumix.Output[*Provider] { + return pulumix.Output[*Provider]{ + OutputState: o.OutputState, + } +} + func init() { pulumi.RegisterInputType(reflect.TypeOf((*ProviderInput)(nil)).Elem(), &Provider{}) pulumi.RegisterOutputType(ProviderOutput{}) diff --git a/sdk/go/kubernetes/pulumiTypes.go b/sdk/go/kubernetes/pulumiTypes.go index 579b870653..9a1a028202 100644 --- a/sdk/go/kubernetes/pulumiTypes.go +++ b/sdk/go/kubernetes/pulumiTypes.go @@ -9,6 +9,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -136,6 +137,12 @@ func (i HelmReleaseSettingsArgs) ToHelmReleaseSettingsOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSettingsOutput) } +func (i HelmReleaseSettingsArgs) ToOutput(ctx context.Context) pulumix.Output[HelmReleaseSettings] { + return pulumix.Output[HelmReleaseSettings]{ + OutputState: i.ToHelmReleaseSettingsOutputWithContext(ctx).OutputState, + } +} + func (i HelmReleaseSettingsArgs) ToHelmReleaseSettingsPtrOutput() HelmReleaseSettingsPtrOutput { return i.ToHelmReleaseSettingsPtrOutputWithContext(context.Background()) } @@ -177,6 +184,12 @@ func (i *helmReleaseSettingsPtrType) ToHelmReleaseSettingsPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSettingsPtrOutput) } +func (i *helmReleaseSettingsPtrType) ToOutput(ctx context.Context) pulumix.Output[*HelmReleaseSettings] { + return pulumix.Output[*HelmReleaseSettings]{ + OutputState: i.ToHelmReleaseSettingsPtrOutputWithContext(ctx).OutputState, + } +} + // Options to configure the Helm Release resource. type HelmReleaseSettingsOutput struct{ *pulumi.OutputState } @@ -202,6 +215,12 @@ func (o HelmReleaseSettingsOutput) ToHelmReleaseSettingsPtrOutputWithContext(ctx }).(HelmReleaseSettingsPtrOutput) } +func (o HelmReleaseSettingsOutput) ToOutput(ctx context.Context) pulumix.Output[HelmReleaseSettings] { + return pulumix.Output[HelmReleaseSettings]{ + OutputState: o.OutputState, + } +} + // The backend storage driver for Helm. Values are: configmap, secret, memory, sql. func (o HelmReleaseSettingsOutput) Driver() pulumi.StringPtrOutput { return o.ApplyT(func(v HelmReleaseSettings) *string { return v.Driver }).(pulumi.StringPtrOutput) @@ -241,6 +260,12 @@ func (o HelmReleaseSettingsPtrOutput) ToHelmReleaseSettingsPtrOutputWithContext( return o } +func (o HelmReleaseSettingsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*HelmReleaseSettings] { + return pulumix.Output[*HelmReleaseSettings]{ + OutputState: o.OutputState, + } +} + func (o HelmReleaseSettingsPtrOutput) Elem() HelmReleaseSettingsOutput { return o.ApplyT(func(v *HelmReleaseSettings) HelmReleaseSettings { if v != nil { @@ -394,6 +419,12 @@ func (i KubeClientSettingsArgs) ToKubeClientSettingsOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(KubeClientSettingsOutput) } +func (i KubeClientSettingsArgs) ToOutput(ctx context.Context) pulumix.Output[KubeClientSettings] { + return pulumix.Output[KubeClientSettings]{ + OutputState: i.ToKubeClientSettingsOutputWithContext(ctx).OutputState, + } +} + func (i KubeClientSettingsArgs) ToKubeClientSettingsPtrOutput() KubeClientSettingsPtrOutput { return i.ToKubeClientSettingsPtrOutputWithContext(context.Background()) } @@ -435,6 +466,12 @@ func (i *kubeClientSettingsPtrType) ToKubeClientSettingsPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(KubeClientSettingsPtrOutput) } +func (i *kubeClientSettingsPtrType) ToOutput(ctx context.Context) pulumix.Output[*KubeClientSettings] { + return pulumix.Output[*KubeClientSettings]{ + OutputState: i.ToKubeClientSettingsPtrOutputWithContext(ctx).OutputState, + } +} + // Options for tuning the Kubernetes client used by a Provider. type KubeClientSettingsOutput struct{ *pulumi.OutputState } @@ -460,6 +497,12 @@ func (o KubeClientSettingsOutput) ToKubeClientSettingsPtrOutputWithContext(ctx c }).(KubeClientSettingsPtrOutput) } +func (o KubeClientSettingsOutput) ToOutput(ctx context.Context) pulumix.Output[KubeClientSettings] { + return pulumix.Output[KubeClientSettings]{ + OutputState: o.OutputState, + } +} + // Maximum burst for throttle. Default value is 10. func (o KubeClientSettingsOutput) Burst() pulumi.IntPtrOutput { return o.ApplyT(func(v KubeClientSettings) *int { return v.Burst }).(pulumi.IntPtrOutput) @@ -489,6 +532,12 @@ func (o KubeClientSettingsPtrOutput) ToKubeClientSettingsPtrOutputWithContext(ct return o } +func (o KubeClientSettingsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*KubeClientSettings] { + return pulumix.Output[*KubeClientSettings]{ + OutputState: o.OutputState, + } +} + func (o KubeClientSettingsPtrOutput) Elem() KubeClientSettingsOutput { return o.ApplyT(func(v *KubeClientSettings) KubeClientSettings { if v != nil { diff --git a/sdk/go/kubernetes/rbac/v1/clusterRole.go b/sdk/go/kubernetes/rbac/v1/clusterRole.go index 692403375e..506e179936 100644 --- a/sdk/go/kubernetes/rbac/v1/clusterRole.go +++ b/sdk/go/kubernetes/rbac/v1/clusterRole.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. @@ -128,6 +129,12 @@ func (i *ClusterRole) ToClusterRoleOutputWithContext(ctx context.Context) Cluste return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleOutput) } +func (i *ClusterRole) ToOutput(ctx context.Context) pulumix.Output[*ClusterRole] { + return pulumix.Output[*ClusterRole]{ + OutputState: i.ToClusterRoleOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleArrayInput is an input type that accepts ClusterRoleArray and ClusterRoleArrayOutput values. // You can construct a concrete instance of `ClusterRoleArrayInput` via: // @@ -153,6 +160,12 @@ func (i ClusterRoleArray) ToClusterRoleArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleArrayOutput) } +func (i ClusterRoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRole] { + return pulumix.Output[[]*ClusterRole]{ + OutputState: i.ToClusterRoleArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleMapInput is an input type that accepts ClusterRoleMap and ClusterRoleMapOutput values. // You can construct a concrete instance of `ClusterRoleMapInput` via: // @@ -178,6 +191,12 @@ func (i ClusterRoleMap) ToClusterRoleMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleMapOutput) } +func (i ClusterRoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRole] { + return pulumix.Output[map[string]*ClusterRole]{ + OutputState: i.ToClusterRoleMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleOutput struct{ *pulumi.OutputState } func (ClusterRoleOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o ClusterRoleOutput) ToClusterRoleOutputWithContext(ctx context.Context) C return o } +func (o ClusterRoleOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRole] { + return pulumix.Output[*ClusterRole]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRoleOutput) AggregationRule() AggregationRuleOutput { return o.ApplyT(func(v *ClusterRole) AggregationRuleOutput { return v.AggregationRule }).(AggregationRuleOutput) @@ -231,6 +256,12 @@ func (o ClusterRoleArrayOutput) ToClusterRoleArrayOutputWithContext(ctx context. return o } +func (o ClusterRoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRole] { + return pulumix.Output[[]*ClusterRole]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleArrayOutput) Index(i pulumi.IntInput) ClusterRoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRole { return vs[0].([]*ClusterRole)[vs[1].(int)] @@ -251,6 +282,12 @@ func (o ClusterRoleMapOutput) ToClusterRoleMapOutputWithContext(ctx context.Cont return o } +func (o ClusterRoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRole] { + return pulumix.Output[map[string]*ClusterRole]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRole { return vs[0].(map[string]*ClusterRole)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/clusterRoleBinding.go b/sdk/go/kubernetes/rbac/v1/clusterRoleBinding.go index e4d3a8ce11..6aac556677 100644 --- a/sdk/go/kubernetes/rbac/v1/clusterRoleBinding.go +++ b/sdk/go/kubernetes/rbac/v1/clusterRoleBinding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. @@ -132,6 +133,12 @@ func (i *ClusterRoleBinding) ToClusterRoleBindingOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingOutput) } +func (i *ClusterRoleBinding) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBinding] { + return pulumix.Output[*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingArrayInput is an input type that accepts ClusterRoleBindingArray and ClusterRoleBindingArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingArrayInput` via: // @@ -157,6 +164,12 @@ func (i ClusterRoleBindingArray) ToClusterRoleBindingArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingArrayOutput) } +func (i ClusterRoleBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBinding] { + return pulumix.Output[[]*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingMapInput is an input type that accepts ClusterRoleBindingMap and ClusterRoleBindingMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingMapInput` via: // @@ -182,6 +195,12 @@ func (i ClusterRoleBindingMap) ToClusterRoleBindingMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingMapOutput) } +func (i ClusterRoleBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBinding] { + return pulumix.Output[map[string]*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o ClusterRoleBindingOutput) ToClusterRoleBindingOutputWithContext(ctx cont return o } +func (o ClusterRoleBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBinding] { + return pulumix.Output[*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o ClusterRoleBindingArrayOutput) ToClusterRoleBindingArrayOutputWithContex return o } +func (o ClusterRoleBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBinding] { + return pulumix.Output[[]*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBinding { return vs[0].([]*ClusterRoleBinding)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o ClusterRoleBindingMapOutput) ToClusterRoleBindingMapOutputWithContext(ct return o } +func (o ClusterRoleBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBinding] { + return pulumix.Output[map[string]*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBinding { return vs[0].(map[string]*ClusterRoleBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/clusterRoleBindingList.go b/sdk/go/kubernetes/rbac/v1/clusterRoleBindingList.go index 2ca2d1fe7c..b9dca09a29 100644 --- a/sdk/go/kubernetes/rbac/v1/clusterRoleBindingList.go +++ b/sdk/go/kubernetes/rbac/v1/clusterRoleBindingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleBindingList is a collection of ClusterRoleBindings @@ -117,6 +118,12 @@ func (i *ClusterRoleBindingList) ToClusterRoleBindingListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListOutput) } +func (i *ClusterRoleBindingList) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingList] { + return pulumix.Output[*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingListArrayInput is an input type that accepts ClusterRoleBindingListArray and ClusterRoleBindingListArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterRoleBindingListArray) ToClusterRoleBindingListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListArrayOutput) } +func (i ClusterRoleBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingList] { + return pulumix.Output[[]*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingListMapInput is an input type that accepts ClusterRoleBindingListMap and ClusterRoleBindingListMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterRoleBindingListMap) ToClusterRoleBindingListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListMapOutput) } +func (i ClusterRoleBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingList] { + return pulumix.Output[map[string]*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingListOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterRoleBindingListOutput) ToClusterRoleBindingListOutputWithContext( return o } +func (o ClusterRoleBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingList] { + return pulumix.Output[*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterRoleBindingListArrayOutput) ToClusterRoleBindingListArrayOutputWi return o } +func (o ClusterRoleBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingList] { + return pulumix.Output[[]*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingListArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBindingList { return vs[0].([]*ClusterRoleBindingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterRoleBindingListMapOutput) ToClusterRoleBindingListMapOutputWithCo return o } +func (o ClusterRoleBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingList] { + return pulumix.Output[map[string]*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingListMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBindingList { return vs[0].(map[string]*ClusterRoleBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/clusterRoleBindingPatch.go b/sdk/go/kubernetes/rbac/v1/clusterRoleBindingPatch.go index 917ad12036..7a27d1f258 100644 --- a/sdk/go/kubernetes/rbac/v1/clusterRoleBindingPatch.go +++ b/sdk/go/kubernetes/rbac/v1/clusterRoleBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ClusterRoleBindingPatch) ToClusterRoleBindingPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchOutput) } +func (i *ClusterRoleBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingPatch] { + return pulumix.Output[*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingPatchArrayInput is an input type that accepts ClusterRoleBindingPatchArray and ClusterRoleBindingPatchArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ClusterRoleBindingPatchArray) ToClusterRoleBindingPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchArrayOutput) } +func (i ClusterRoleBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingPatch] { + return pulumix.Output[[]*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingPatchMapInput is an input type that accepts ClusterRoleBindingPatchMap and ClusterRoleBindingPatchMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ClusterRoleBindingPatchMap) ToClusterRoleBindingPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchMapOutput) } +func (i ClusterRoleBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingPatch] { + return pulumix.Output[map[string]*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingPatchOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ClusterRoleBindingPatchOutput) ToClusterRoleBindingPatchOutputWithContex return o } +func (o ClusterRoleBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingPatch] { + return pulumix.Output[*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ClusterRoleBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o ClusterRoleBindingPatchArrayOutput) ToClusterRoleBindingPatchArrayOutput return o } +func (o ClusterRoleBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingPatch] { + return pulumix.Output[[]*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingPatchArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBindingPatch { return vs[0].([]*ClusterRoleBindingPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ClusterRoleBindingPatchMapOutput) ToClusterRoleBindingPatchMapOutputWith return o } +func (o ClusterRoleBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingPatch] { + return pulumix.Output[map[string]*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingPatchMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBindingPatch { return vs[0].(map[string]*ClusterRoleBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/clusterRoleList.go b/sdk/go/kubernetes/rbac/v1/clusterRoleList.go index ce99ad0047..38efa44048 100644 --- a/sdk/go/kubernetes/rbac/v1/clusterRoleList.go +++ b/sdk/go/kubernetes/rbac/v1/clusterRoleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleList is a collection of ClusterRoles @@ -117,6 +118,12 @@ func (i *ClusterRoleList) ToClusterRoleListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListOutput) } +func (i *ClusterRoleList) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleList] { + return pulumix.Output[*ClusterRoleList]{ + OutputState: i.ToClusterRoleListOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleListArrayInput is an input type that accepts ClusterRoleListArray and ClusterRoleListArrayOutput values. // You can construct a concrete instance of `ClusterRoleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterRoleListArray) ToClusterRoleListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListArrayOutput) } +func (i ClusterRoleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleList] { + return pulumix.Output[[]*ClusterRoleList]{ + OutputState: i.ToClusterRoleListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleListMapInput is an input type that accepts ClusterRoleListMap and ClusterRoleListMapOutput values. // You can construct a concrete instance of `ClusterRoleListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterRoleListMap) ToClusterRoleListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListMapOutput) } +func (i ClusterRoleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleList] { + return pulumix.Output[map[string]*ClusterRoleList]{ + OutputState: i.ToClusterRoleListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleListOutput struct{ *pulumi.OutputState } func (ClusterRoleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterRoleListOutput) ToClusterRoleListOutputWithContext(ctx context.Co return o } +func (o ClusterRoleListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleList] { + return pulumix.Output[*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterRoleListArrayOutput) ToClusterRoleListArrayOutputWithContext(ctx return o } +func (o ClusterRoleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleList] { + return pulumix.Output[[]*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleListArrayOutput) Index(i pulumi.IntInput) ClusterRoleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleList { return vs[0].([]*ClusterRoleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterRoleListMapOutput) ToClusterRoleListMapOutputWithContext(ctx cont return o } +func (o ClusterRoleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleList] { + return pulumix.Output[map[string]*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleListMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleList { return vs[0].(map[string]*ClusterRoleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/clusterRolePatch.go b/sdk/go/kubernetes/rbac/v1/clusterRolePatch.go index ab159ee803..55ef1b31cc 100644 --- a/sdk/go/kubernetes/rbac/v1/clusterRolePatch.go +++ b/sdk/go/kubernetes/rbac/v1/clusterRolePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ClusterRolePatch) ToClusterRolePatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchOutput) } +func (i *ClusterRolePatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterRolePatch] { + return pulumix.Output[*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchOutputWithContext(ctx).OutputState, + } +} + // ClusterRolePatchArrayInput is an input type that accepts ClusterRolePatchArray and ClusterRolePatchArrayOutput values. // You can construct a concrete instance of `ClusterRolePatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ClusterRolePatchArray) ToClusterRolePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchArrayOutput) } +func (i ClusterRolePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRolePatch] { + return pulumix.Output[[]*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRolePatchMapInput is an input type that accepts ClusterRolePatchMap and ClusterRolePatchMapOutput values. // You can construct a concrete instance of `ClusterRolePatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ClusterRolePatchMap) ToClusterRolePatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchMapOutput) } +func (i ClusterRolePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRolePatch] { + return pulumix.Output[map[string]*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRolePatchOutput struct{ *pulumi.OutputState } func (ClusterRolePatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ClusterRolePatchOutput) ToClusterRolePatchOutputWithContext(ctx context. return o } +func (o ClusterRolePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRolePatch] { + return pulumix.Output[*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRolePatchOutput) AggregationRule() AggregationRulePatchPtrOutput { return o.ApplyT(func(v *ClusterRolePatch) AggregationRulePatchPtrOutput { return v.AggregationRule }).(AggregationRulePatchPtrOutput) @@ -237,6 +262,12 @@ func (o ClusterRolePatchArrayOutput) ToClusterRolePatchArrayOutputWithContext(ct return o } +func (o ClusterRolePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRolePatch] { + return pulumix.Output[[]*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRolePatchArrayOutput) Index(i pulumi.IntInput) ClusterRolePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRolePatch { return vs[0].([]*ClusterRolePatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ClusterRolePatchMapOutput) ToClusterRolePatchMapOutputWithContext(ctx co return o } +func (o ClusterRolePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRolePatch] { + return pulumix.Output[map[string]*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRolePatchMapOutput) MapIndex(k pulumi.StringInput) ClusterRolePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRolePatch { return vs[0].(map[string]*ClusterRolePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/pulumiTypes.go b/sdk/go/kubernetes/rbac/v1/pulumiTypes.go index 1e3e73f8ae..cffd9e7e85 100644 --- a/sdk/go/kubernetes/rbac/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/rbac/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -49,6 +50,12 @@ func (i AggregationRuleArgs) ToAggregationRuleOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AggregationRuleOutput) } +func (i AggregationRuleArgs) ToOutput(ctx context.Context) pulumix.Output[AggregationRule] { + return pulumix.Output[AggregationRule]{ + OutputState: i.ToAggregationRuleOutputWithContext(ctx).OutputState, + } +} + func (i AggregationRuleArgs) ToAggregationRulePtrOutput() AggregationRulePtrOutput { return i.ToAggregationRulePtrOutputWithContext(context.Background()) } @@ -90,6 +97,12 @@ func (i *aggregationRulePtrType) ToAggregationRulePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePtrOutput) } +func (i *aggregationRulePtrType) ToOutput(ctx context.Context) pulumix.Output[*AggregationRule] { + return pulumix.Output[*AggregationRule]{ + OutputState: i.ToAggregationRulePtrOutputWithContext(ctx).OutputState, + } +} + // AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole type AggregationRuleOutput struct{ *pulumi.OutputState } @@ -115,6 +128,12 @@ func (o AggregationRuleOutput) ToAggregationRulePtrOutputWithContext(ctx context }).(AggregationRulePtrOutput) } +func (o AggregationRuleOutput) ToOutput(ctx context.Context) pulumix.Output[AggregationRule] { + return pulumix.Output[AggregationRule]{ + OutputState: o.OutputState, + } +} + // ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added func (o AggregationRuleOutput) ClusterRoleSelectors() metav1.LabelSelectorArrayOutput { return o.ApplyT(func(v AggregationRule) []metav1.LabelSelector { return v.ClusterRoleSelectors }).(metav1.LabelSelectorArrayOutput) @@ -134,6 +153,12 @@ func (o AggregationRulePtrOutput) ToAggregationRulePtrOutputWithContext(ctx cont return o } +func (o AggregationRulePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AggregationRule] { + return pulumix.Output[*AggregationRule]{ + OutputState: o.OutputState, + } +} + func (o AggregationRulePtrOutput) Elem() AggregationRuleOutput { return o.ApplyT(func(v *AggregationRule) AggregationRule { if v != nil { @@ -189,6 +214,12 @@ func (i AggregationRulePatchArgs) ToAggregationRulePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePatchOutput) } +func (i AggregationRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AggregationRulePatch] { + return pulumix.Output[AggregationRulePatch]{ + OutputState: i.ToAggregationRulePatchOutputWithContext(ctx).OutputState, + } +} + func (i AggregationRulePatchArgs) ToAggregationRulePatchPtrOutput() AggregationRulePatchPtrOutput { return i.ToAggregationRulePatchPtrOutputWithContext(context.Background()) } @@ -230,6 +261,12 @@ func (i *aggregationRulePatchPtrType) ToAggregationRulePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePatchPtrOutput) } +func (i *aggregationRulePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AggregationRulePatch] { + return pulumix.Output[*AggregationRulePatch]{ + OutputState: i.ToAggregationRulePatchPtrOutputWithContext(ctx).OutputState, + } +} + // AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole type AggregationRulePatchOutput struct{ *pulumi.OutputState } @@ -255,6 +292,12 @@ func (o AggregationRulePatchOutput) ToAggregationRulePatchPtrOutputWithContext(c }).(AggregationRulePatchPtrOutput) } +func (o AggregationRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AggregationRulePatch] { + return pulumix.Output[AggregationRulePatch]{ + OutputState: o.OutputState, + } +} + // ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added func (o AggregationRulePatchOutput) ClusterRoleSelectors() metav1.LabelSelectorPatchArrayOutput { return o.ApplyT(func(v AggregationRulePatch) []metav1.LabelSelectorPatch { return v.ClusterRoleSelectors }).(metav1.LabelSelectorPatchArrayOutput) @@ -274,6 +317,12 @@ func (o AggregationRulePatchPtrOutput) ToAggregationRulePatchPtrOutputWithContex return o } +func (o AggregationRulePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AggregationRulePatch] { + return pulumix.Output[*AggregationRulePatch]{ + OutputState: o.OutputState, + } +} + func (o AggregationRulePatchPtrOutput) Elem() AggregationRulePatchOutput { return o.ApplyT(func(v *AggregationRulePatch) AggregationRulePatch { if v != nil { @@ -345,6 +394,12 @@ func (i ClusterRoleTypeArgs) ToClusterRoleTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleTypeOutput) } +func (i ClusterRoleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleType] { + return pulumix.Output[ClusterRoleType]{ + OutputState: i.ToClusterRoleTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleTypeArrayInput is an input type that accepts ClusterRoleTypeArray and ClusterRoleTypeArrayOutput values. // You can construct a concrete instance of `ClusterRoleTypeArrayInput` via: // @@ -370,6 +425,12 @@ func (i ClusterRoleTypeArray) ToClusterRoleTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleTypeArrayOutput) } +func (i ClusterRoleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleType] { + return pulumix.Output[[]ClusterRoleType]{ + OutputState: i.ToClusterRoleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. type ClusterRoleTypeOutput struct{ *pulumi.OutputState } @@ -385,6 +446,12 @@ func (o ClusterRoleTypeOutput) ToClusterRoleTypeOutputWithContext(ctx context.Co return o } +func (o ClusterRoleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleType] { + return pulumix.Output[ClusterRoleType]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRoleTypeOutput) AggregationRule() AggregationRulePtrOutput { return o.ApplyT(func(v ClusterRoleType) *AggregationRule { return v.AggregationRule }).(AggregationRulePtrOutput) @@ -424,6 +491,12 @@ func (o ClusterRoleTypeArrayOutput) ToClusterRoleTypeArrayOutputWithContext(ctx return o } +func (o ClusterRoleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleType] { + return pulumix.Output[[]ClusterRoleType]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleTypeArrayOutput) Index(i pulumi.IntInput) ClusterRoleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterRoleType { return vs[0].([]ClusterRoleType)[vs[1].(int)] @@ -481,6 +554,12 @@ func (i ClusterRoleBindingTypeArgs) ToClusterRoleBindingTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingTypeOutput) } +func (i ClusterRoleBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingType] { + return pulumix.Output[ClusterRoleBindingType]{ + OutputState: i.ToClusterRoleBindingTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingTypeArrayInput is an input type that accepts ClusterRoleBindingTypeArray and ClusterRoleBindingTypeArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingTypeArrayInput` via: // @@ -506,6 +585,12 @@ func (i ClusterRoleBindingTypeArray) ToClusterRoleBindingTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingTypeArrayOutput) } +func (i ClusterRoleBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleBindingType] { + return pulumix.Output[[]ClusterRoleBindingType]{ + OutputState: i.ToClusterRoleBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. type ClusterRoleBindingTypeOutput struct{ *pulumi.OutputState } @@ -521,6 +606,12 @@ func (o ClusterRoleBindingTypeOutput) ToClusterRoleBindingTypeOutputWithContext( return o } +func (o ClusterRoleBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingType] { + return pulumix.Output[ClusterRoleBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -560,6 +651,12 @@ func (o ClusterRoleBindingTypeArrayOutput) ToClusterRoleBindingTypeArrayOutputWi return o } +func (o ClusterRoleBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleBindingType] { + return pulumix.Output[[]ClusterRoleBindingType]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingTypeArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterRoleBindingType { return vs[0].([]ClusterRoleBindingType)[vs[1].(int)] @@ -613,6 +710,12 @@ func (i ClusterRoleBindingListTypeArgs) ToClusterRoleBindingListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListTypeOutput) } +func (i ClusterRoleBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingListType] { + return pulumix.Output[ClusterRoleBindingListType]{ + OutputState: i.ToClusterRoleBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingList is a collection of ClusterRoleBindings type ClusterRoleBindingListTypeOutput struct{ *pulumi.OutputState } @@ -628,6 +731,12 @@ func (o ClusterRoleBindingListTypeOutput) ToClusterRoleBindingListTypeOutputWith return o } +func (o ClusterRoleBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingListType] { + return pulumix.Output[ClusterRoleBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -699,6 +808,12 @@ func (i ClusterRoleBindingPatchTypeArgs) ToClusterRoleBindingPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchTypeOutput) } +func (i ClusterRoleBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingPatchType] { + return pulumix.Output[ClusterRoleBindingPatchType]{ + OutputState: i.ToClusterRoleBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. type ClusterRoleBindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -714,6 +829,12 @@ func (o ClusterRoleBindingPatchTypeOutput) ToClusterRoleBindingPatchTypeOutputWi return o } +func (o ClusterRoleBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingPatchType] { + return pulumix.Output[ClusterRoleBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -786,6 +907,12 @@ func (i ClusterRoleListTypeArgs) ToClusterRoleListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListTypeOutput) } +func (i ClusterRoleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleListType] { + return pulumix.Output[ClusterRoleListType]{ + OutputState: i.ToClusterRoleListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleList is a collection of ClusterRoles type ClusterRoleListTypeOutput struct{ *pulumi.OutputState } @@ -801,6 +928,12 @@ func (o ClusterRoleListTypeOutput) ToClusterRoleListTypeOutputWithContext(ctx co return o } +func (o ClusterRoleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleListType] { + return pulumix.Output[ClusterRoleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -872,6 +1005,12 @@ func (i ClusterRolePatchTypeArgs) ToClusterRolePatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchTypeOutput) } +func (i ClusterRolePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRolePatchType] { + return pulumix.Output[ClusterRolePatchType]{ + OutputState: i.ToClusterRolePatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. type ClusterRolePatchTypeOutput struct{ *pulumi.OutputState } @@ -887,6 +1026,12 @@ func (o ClusterRolePatchTypeOutput) ToClusterRolePatchTypeOutputWithContext(ctx return o } +func (o ClusterRolePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRolePatchType] { + return pulumix.Output[ClusterRolePatchType]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRolePatchTypeOutput) AggregationRule() AggregationRulePatchPtrOutput { return o.ApplyT(func(v ClusterRolePatchType) *AggregationRulePatch { return v.AggregationRule }).(AggregationRulePatchPtrOutput) @@ -963,6 +1108,12 @@ func (i PolicyRuleArgs) ToPolicyRuleOutputWithContext(ctx context.Context) Polic return pulumi.ToOutputWithContext(ctx, i).(PolicyRuleOutput) } +func (i PolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRule] { + return pulumix.Output[PolicyRule]{ + OutputState: i.ToPolicyRuleOutputWithContext(ctx).OutputState, + } +} + // PolicyRuleArrayInput is an input type that accepts PolicyRuleArray and PolicyRuleArrayOutput values. // You can construct a concrete instance of `PolicyRuleArrayInput` via: // @@ -988,6 +1139,12 @@ func (i PolicyRuleArray) ToPolicyRuleArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PolicyRuleArrayOutput) } +func (i PolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRule] { + return pulumix.Output[[]PolicyRule]{ + OutputState: i.ToPolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. type PolicyRuleOutput struct{ *pulumi.OutputState } @@ -1003,6 +1160,12 @@ func (o PolicyRuleOutput) ToPolicyRuleOutputWithContext(ctx context.Context) Pol return o } +func (o PolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRule] { + return pulumix.Output[PolicyRule]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "" represents the core API group and "*" represents all API groups. func (o PolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v PolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1042,6 +1205,12 @@ func (o PolicyRuleArrayOutput) ToPolicyRuleArrayOutputWithContext(ctx context.Co return o } +func (o PolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRule] { + return pulumix.Output[[]PolicyRule]{ + OutputState: o.OutputState, + } +} + func (o PolicyRuleArrayOutput) Index(i pulumi.IntInput) PolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRule { return vs[0].([]PolicyRule)[vs[1].(int)] @@ -1099,6 +1268,12 @@ func (i PolicyRulePatchArgs) ToPolicyRulePatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PolicyRulePatchOutput) } +func (i PolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulePatch] { + return pulumix.Output[PolicyRulePatch]{ + OutputState: i.ToPolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulePatchArrayInput is an input type that accepts PolicyRulePatchArray and PolicyRulePatchArrayOutput values. // You can construct a concrete instance of `PolicyRulePatchArrayInput` via: // @@ -1124,6 +1299,12 @@ func (i PolicyRulePatchArray) ToPolicyRulePatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PolicyRulePatchArrayOutput) } +func (i PolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulePatch] { + return pulumix.Output[[]PolicyRulePatch]{ + OutputState: i.ToPolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. type PolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -1139,6 +1320,12 @@ func (o PolicyRulePatchOutput) ToPolicyRulePatchOutputWithContext(ctx context.Co return o } +func (o PolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulePatch] { + return pulumix.Output[PolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "" represents the core API group and "*" represents all API groups. func (o PolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v PolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1178,6 +1365,12 @@ func (o PolicyRulePatchArrayOutput) ToPolicyRulePatchArrayOutputWithContext(ctx return o } +func (o PolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulePatch] { + return pulumix.Output[[]PolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulePatchArrayOutput) Index(i pulumi.IntInput) PolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulePatch { return vs[0].([]PolicyRulePatch)[vs[1].(int)] @@ -1231,6 +1424,12 @@ func (i RoleTypeArgs) ToRoleTypeOutputWithContext(ctx context.Context) RoleTypeO return pulumi.ToOutputWithContext(ctx, i).(RoleTypeOutput) } +func (i RoleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleType] { + return pulumix.Output[RoleType]{ + OutputState: i.ToRoleTypeOutputWithContext(ctx).OutputState, + } +} + // RoleTypeArrayInput is an input type that accepts RoleTypeArray and RoleTypeArrayOutput values. // You can construct a concrete instance of `RoleTypeArrayInput` via: // @@ -1256,6 +1455,12 @@ func (i RoleTypeArray) ToRoleTypeArrayOutputWithContext(ctx context.Context) Rol return pulumi.ToOutputWithContext(ctx, i).(RoleTypeArrayOutput) } +func (i RoleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RoleType] { + return pulumix.Output[[]RoleType]{ + OutputState: i.ToRoleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. type RoleTypeOutput struct{ *pulumi.OutputState } @@ -1271,6 +1476,12 @@ func (o RoleTypeOutput) ToRoleTypeOutputWithContext(ctx context.Context) RoleTyp return o } +func (o RoleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleType] { + return pulumix.Output[RoleType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1305,6 +1516,12 @@ func (o RoleTypeArrayOutput) ToRoleTypeArrayOutputWithContext(ctx context.Contex return o } +func (o RoleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RoleType] { + return pulumix.Output[[]RoleType]{ + OutputState: o.OutputState, + } +} + func (o RoleTypeArrayOutput) Index(i pulumi.IntInput) RoleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RoleType { return vs[0].([]RoleType)[vs[1].(int)] @@ -1362,6 +1579,12 @@ func (i RoleBindingTypeArgs) ToRoleBindingTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingTypeOutput) } +func (i RoleBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingType] { + return pulumix.Output[RoleBindingType]{ + OutputState: i.ToRoleBindingTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBindingTypeArrayInput is an input type that accepts RoleBindingTypeArray and RoleBindingTypeArrayOutput values. // You can construct a concrete instance of `RoleBindingTypeArrayInput` via: // @@ -1387,6 +1610,12 @@ func (i RoleBindingTypeArray) ToRoleBindingTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingTypeArrayOutput) } +func (i RoleBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RoleBindingType] { + return pulumix.Output[[]RoleBindingType]{ + OutputState: i.ToRoleBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. type RoleBindingTypeOutput struct{ *pulumi.OutputState } @@ -1402,6 +1631,12 @@ func (o RoleBindingTypeOutput) ToRoleBindingTypeOutputWithContext(ctx context.Co return o } +func (o RoleBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingType] { + return pulumix.Output[RoleBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1441,6 +1676,12 @@ func (o RoleBindingTypeArrayOutput) ToRoleBindingTypeArrayOutputWithContext(ctx return o } +func (o RoleBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RoleBindingType] { + return pulumix.Output[[]RoleBindingType]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingTypeArrayOutput) Index(i pulumi.IntInput) RoleBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RoleBindingType { return vs[0].([]RoleBindingType)[vs[1].(int)] @@ -1494,6 +1735,12 @@ func (i RoleBindingListTypeArgs) ToRoleBindingListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListTypeOutput) } +func (i RoleBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingListType] { + return pulumix.Output[RoleBindingListType]{ + OutputState: i.ToRoleBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBindingList is a collection of RoleBindings type RoleBindingListTypeOutput struct{ *pulumi.OutputState } @@ -1509,6 +1756,12 @@ func (o RoleBindingListTypeOutput) ToRoleBindingListTypeOutputWithContext(ctx co return o } +func (o RoleBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingListType] { + return pulumix.Output[RoleBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1580,6 +1833,12 @@ func (i RoleBindingPatchTypeArgs) ToRoleBindingPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchTypeOutput) } +func (i RoleBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingPatchType] { + return pulumix.Output[RoleBindingPatchType]{ + OutputState: i.ToRoleBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. type RoleBindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -1595,6 +1854,12 @@ func (o RoleBindingPatchTypeOutput) ToRoleBindingPatchTypeOutputWithContext(ctx return o } +func (o RoleBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingPatchType] { + return pulumix.Output[RoleBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1667,6 +1932,12 @@ func (i RoleListTypeArgs) ToRoleListTypeOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleListTypeOutput) } +func (i RoleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleListType] { + return pulumix.Output[RoleListType]{ + OutputState: i.ToRoleListTypeOutputWithContext(ctx).OutputState, + } +} + // RoleList is a collection of Roles type RoleListTypeOutput struct{ *pulumi.OutputState } @@ -1682,6 +1953,12 @@ func (o RoleListTypeOutput) ToRoleListTypeOutputWithContext(ctx context.Context) return o } +func (o RoleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleListType] { + return pulumix.Output[RoleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1749,6 +2026,12 @@ func (i RolePatchTypeArgs) ToRolePatchTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(RolePatchTypeOutput) } +func (i RolePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RolePatchType] { + return pulumix.Output[RolePatchType]{ + OutputState: i.ToRolePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. type RolePatchTypeOutput struct{ *pulumi.OutputState } @@ -1764,6 +2047,12 @@ func (o RolePatchTypeOutput) ToRolePatchTypeOutputWithContext(ctx context.Contex return o } +func (o RolePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RolePatchType] { + return pulumix.Output[RolePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RolePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RolePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1827,6 +2116,12 @@ func (i RoleRefArgs) ToRoleRefOutputWithContext(ctx context.Context) RoleRefOutp return pulumi.ToOutputWithContext(ctx, i).(RoleRefOutput) } +func (i RoleRefArgs) ToOutput(ctx context.Context) pulumix.Output[RoleRef] { + return pulumix.Output[RoleRef]{ + OutputState: i.ToRoleRefOutputWithContext(ctx).OutputState, + } +} + // RoleRef contains information that points to the role being used type RoleRefOutput struct{ *pulumi.OutputState } @@ -1842,6 +2137,12 @@ func (o RoleRefOutput) ToRoleRefOutputWithContext(ctx context.Context) RoleRefOu return o } +func (o RoleRefOutput) ToOutput(ctx context.Context) pulumix.Output[RoleRef] { + return pulumix.Output[RoleRef]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced func (o RoleRefOutput) ApiGroup() pulumi.StringOutput { return o.ApplyT(func(v RoleRef) string { return v.ApiGroup }).(pulumi.StringOutput) @@ -1900,6 +2201,12 @@ func (i RoleRefPatchArgs) ToRoleRefPatchOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleRefPatchOutput) } +func (i RoleRefPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RoleRefPatch] { + return pulumix.Output[RoleRefPatch]{ + OutputState: i.ToRoleRefPatchOutputWithContext(ctx).OutputState, + } +} + func (i RoleRefPatchArgs) ToRoleRefPatchPtrOutput() RoleRefPatchPtrOutput { return i.ToRoleRefPatchPtrOutputWithContext(context.Background()) } @@ -1941,6 +2248,12 @@ func (i *roleRefPatchPtrType) ToRoleRefPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(RoleRefPatchPtrOutput) } +func (i *roleRefPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RoleRefPatch] { + return pulumix.Output[*RoleRefPatch]{ + OutputState: i.ToRoleRefPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RoleRef contains information that points to the role being used type RoleRefPatchOutput struct{ *pulumi.OutputState } @@ -1966,6 +2279,12 @@ func (o RoleRefPatchOutput) ToRoleRefPatchPtrOutputWithContext(ctx context.Conte }).(RoleRefPatchPtrOutput) } +func (o RoleRefPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RoleRefPatch] { + return pulumix.Output[RoleRefPatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced func (o RoleRefPatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleRefPatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1995,6 +2314,12 @@ func (o RoleRefPatchPtrOutput) ToRoleRefPatchPtrOutputWithContext(ctx context.Co return o } +func (o RoleRefPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleRefPatch] { + return pulumix.Output[*RoleRefPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleRefPatchPtrOutput) Elem() RoleRefPatchOutput { return o.ApplyT(func(v *RoleRefPatch) RoleRefPatch { if v != nil { @@ -2082,6 +2407,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -2107,6 +2438,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. type SubjectOutput struct{ *pulumi.OutputState } @@ -2122,6 +2459,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + // APIGroup holds the API group of the referenced subject. Defaults to "" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io" for User and Group subjects. func (o SubjectOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v Subject) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -2156,6 +2499,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -2209,6 +2558,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -2234,6 +2589,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -2249,6 +2610,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + // APIGroup holds the API group of the referenced subject. Defaults to "" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io" for User and Group subjects. func (o SubjectPatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectPatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -2283,6 +2650,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/rbac/v1/role.go b/sdk/go/kubernetes/rbac/v1/role.go index ea13125fa4..624cfc1065 100644 --- a/sdk/go/kubernetes/rbac/v1/role.go +++ b/sdk/go/kubernetes/rbac/v1/role.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. @@ -122,6 +123,12 @@ func (i *Role) ToRoleOutputWithContext(ctx context.Context) RoleOutput { return pulumi.ToOutputWithContext(ctx, i).(RoleOutput) } +func (i *Role) ToOutput(ctx context.Context) pulumix.Output[*Role] { + return pulumix.Output[*Role]{ + OutputState: i.ToRoleOutputWithContext(ctx).OutputState, + } +} + // RoleArrayInput is an input type that accepts RoleArray and RoleArrayOutput values. // You can construct a concrete instance of `RoleArrayInput` via: // @@ -147,6 +154,12 @@ func (i RoleArray) ToRoleArrayOutputWithContext(ctx context.Context) RoleArrayOu return pulumi.ToOutputWithContext(ctx, i).(RoleArrayOutput) } +func (i RoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*Role] { + return pulumix.Output[[]*Role]{ + OutputState: i.ToRoleArrayOutputWithContext(ctx).OutputState, + } +} + // RoleMapInput is an input type that accepts RoleMap and RoleMapOutput values. // You can construct a concrete instance of `RoleMapInput` via: // @@ -172,6 +185,12 @@ func (i RoleMap) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOutput { return pulumi.ToOutputWithContext(ctx, i).(RoleMapOutput) } +func (i RoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Role] { + return pulumix.Output[map[string]*Role]{ + OutputState: i.ToRoleMapOutputWithContext(ctx).OutputState, + } +} + type RoleOutput struct{ *pulumi.OutputState } func (RoleOutput) ElementType() reflect.Type { @@ -186,6 +205,12 @@ func (o RoleOutput) ToRoleOutputWithContext(ctx context.Context) RoleOutput { return o } +func (o RoleOutput) ToOutput(ctx context.Context) pulumix.Output[*Role] { + return pulumix.Output[*Role]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Role) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -220,6 +245,12 @@ func (o RoleArrayOutput) ToRoleArrayOutputWithContext(ctx context.Context) RoleA return o } +func (o RoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Role] { + return pulumix.Output[[]*Role]{ + OutputState: o.OutputState, + } +} + func (o RoleArrayOutput) Index(i pulumi.IntInput) RoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Role { return vs[0].([]*Role)[vs[1].(int)] @@ -240,6 +271,12 @@ func (o RoleMapOutput) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOu return o } +func (o RoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Role] { + return pulumix.Output[map[string]*Role]{ + OutputState: o.OutputState, + } +} + func (o RoleMapOutput) MapIndex(k pulumi.StringInput) RoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Role { return vs[0].(map[string]*Role)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/roleBinding.go b/sdk/go/kubernetes/rbac/v1/roleBinding.go index fe695a81fd..fc64dd3ca1 100644 --- a/sdk/go/kubernetes/rbac/v1/roleBinding.go +++ b/sdk/go/kubernetes/rbac/v1/roleBinding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. @@ -132,6 +133,12 @@ func (i *RoleBinding) ToRoleBindingOutputWithContext(ctx context.Context) RoleBi return pulumi.ToOutputWithContext(ctx, i).(RoleBindingOutput) } +func (i *RoleBinding) ToOutput(ctx context.Context) pulumix.Output[*RoleBinding] { + return pulumix.Output[*RoleBinding]{ + OutputState: i.ToRoleBindingOutputWithContext(ctx).OutputState, + } +} + // RoleBindingArrayInput is an input type that accepts RoleBindingArray and RoleBindingArrayOutput values. // You can construct a concrete instance of `RoleBindingArrayInput` via: // @@ -157,6 +164,12 @@ func (i RoleBindingArray) ToRoleBindingArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingArrayOutput) } +func (i RoleBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBinding] { + return pulumix.Output[[]*RoleBinding]{ + OutputState: i.ToRoleBindingArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingMapInput is an input type that accepts RoleBindingMap and RoleBindingMapOutput values. // You can construct a concrete instance of `RoleBindingMapInput` via: // @@ -182,6 +195,12 @@ func (i RoleBindingMap) ToRoleBindingMapOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleBindingMapOutput) } +func (i RoleBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBinding] { + return pulumix.Output[map[string]*RoleBinding]{ + OutputState: i.ToRoleBindingMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingOutput struct{ *pulumi.OutputState } func (RoleBindingOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o RoleBindingOutput) ToRoleBindingOutputWithContext(ctx context.Context) R return o } +func (o RoleBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBinding] { + return pulumix.Output[*RoleBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o RoleBindingArrayOutput) ToRoleBindingArrayOutputWithContext(ctx context. return o } +func (o RoleBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBinding] { + return pulumix.Output[[]*RoleBinding]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingArrayOutput) Index(i pulumi.IntInput) RoleBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBinding { return vs[0].([]*RoleBinding)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o RoleBindingMapOutput) ToRoleBindingMapOutputWithContext(ctx context.Cont return o } +func (o RoleBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBinding] { + return pulumix.Output[map[string]*RoleBinding]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingMapOutput) MapIndex(k pulumi.StringInput) RoleBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBinding { return vs[0].(map[string]*RoleBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/roleBindingList.go b/sdk/go/kubernetes/rbac/v1/roleBindingList.go index 425684c891..82ef2a1a32 100644 --- a/sdk/go/kubernetes/rbac/v1/roleBindingList.go +++ b/sdk/go/kubernetes/rbac/v1/roleBindingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleBindingList is a collection of RoleBindings @@ -117,6 +118,12 @@ func (i *RoleBindingList) ToRoleBindingListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListOutput) } +func (i *RoleBindingList) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingList] { + return pulumix.Output[*RoleBindingList]{ + OutputState: i.ToRoleBindingListOutputWithContext(ctx).OutputState, + } +} + // RoleBindingListArrayInput is an input type that accepts RoleBindingListArray and RoleBindingListArrayOutput values. // You can construct a concrete instance of `RoleBindingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RoleBindingListArray) ToRoleBindingListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListArrayOutput) } +func (i RoleBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingList] { + return pulumix.Output[[]*RoleBindingList]{ + OutputState: i.ToRoleBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingListMapInput is an input type that accepts RoleBindingListMap and RoleBindingListMapOutput values. // You can construct a concrete instance of `RoleBindingListMapInput` via: // @@ -167,6 +180,12 @@ func (i RoleBindingListMap) ToRoleBindingListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListMapOutput) } +func (i RoleBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingList] { + return pulumix.Output[map[string]*RoleBindingList]{ + OutputState: i.ToRoleBindingListMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingListOutput struct{ *pulumi.OutputState } func (RoleBindingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RoleBindingListOutput) ToRoleBindingListOutputWithContext(ctx context.Co return o } +func (o RoleBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingList] { + return pulumix.Output[*RoleBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RoleBindingListArrayOutput) ToRoleBindingListArrayOutputWithContext(ctx return o } +func (o RoleBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingList] { + return pulumix.Output[[]*RoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingListArrayOutput) Index(i pulumi.IntInput) RoleBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBindingList { return vs[0].([]*RoleBindingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RoleBindingListMapOutput) ToRoleBindingListMapOutputWithContext(ctx cont return o } +func (o RoleBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingList] { + return pulumix.Output[map[string]*RoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingListMapOutput) MapIndex(k pulumi.StringInput) RoleBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBindingList { return vs[0].(map[string]*RoleBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/roleBindingPatch.go b/sdk/go/kubernetes/rbac/v1/roleBindingPatch.go index fc7a678223..fed615873e 100644 --- a/sdk/go/kubernetes/rbac/v1/roleBindingPatch.go +++ b/sdk/go/kubernetes/rbac/v1/roleBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *RoleBindingPatch) ToRoleBindingPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchOutput) } +func (i *RoleBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingPatch] { + return pulumix.Output[*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchOutputWithContext(ctx).OutputState, + } +} + // RoleBindingPatchArrayInput is an input type that accepts RoleBindingPatchArray and RoleBindingPatchArrayOutput values. // You can construct a concrete instance of `RoleBindingPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i RoleBindingPatchArray) ToRoleBindingPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchArrayOutput) } +func (i RoleBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingPatch] { + return pulumix.Output[[]*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingPatchMapInput is an input type that accepts RoleBindingPatchMap and RoleBindingPatchMapOutput values. // You can construct a concrete instance of `RoleBindingPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i RoleBindingPatchMap) ToRoleBindingPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchMapOutput) } +func (i RoleBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingPatch] { + return pulumix.Output[map[string]*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingPatchOutput struct{ *pulumi.OutputState } func (RoleBindingPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o RoleBindingPatchOutput) ToRoleBindingPatchOutputWithContext(ctx context. return o } +func (o RoleBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingPatch] { + return pulumix.Output[*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RoleBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o RoleBindingPatchArrayOutput) ToRoleBindingPatchArrayOutputWithContext(ct return o } +func (o RoleBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingPatch] { + return pulumix.Output[[]*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingPatchArrayOutput) Index(i pulumi.IntInput) RoleBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBindingPatch { return vs[0].([]*RoleBindingPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o RoleBindingPatchMapOutput) ToRoleBindingPatchMapOutputWithContext(ctx co return o } +func (o RoleBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingPatch] { + return pulumix.Output[map[string]*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingPatchMapOutput) MapIndex(k pulumi.StringInput) RoleBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBindingPatch { return vs[0].(map[string]*RoleBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/roleList.go b/sdk/go/kubernetes/rbac/v1/roleList.go index f5911e37fb..b18e8e385e 100644 --- a/sdk/go/kubernetes/rbac/v1/roleList.go +++ b/sdk/go/kubernetes/rbac/v1/roleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleList is a collection of Roles @@ -117,6 +118,12 @@ func (i *RoleList) ToRoleListOutputWithContext(ctx context.Context) RoleListOutp return pulumi.ToOutputWithContext(ctx, i).(RoleListOutput) } +func (i *RoleList) ToOutput(ctx context.Context) pulumix.Output[*RoleList] { + return pulumix.Output[*RoleList]{ + OutputState: i.ToRoleListOutputWithContext(ctx).OutputState, + } +} + // RoleListArrayInput is an input type that accepts RoleListArray and RoleListArrayOutput values. // You can construct a concrete instance of `RoleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RoleListArray) ToRoleListArrayOutputWithContext(ctx context.Context) Rol return pulumi.ToOutputWithContext(ctx, i).(RoleListArrayOutput) } +func (i RoleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleList] { + return pulumix.Output[[]*RoleList]{ + OutputState: i.ToRoleListArrayOutputWithContext(ctx).OutputState, + } +} + // RoleListMapInput is an input type that accepts RoleListMap and RoleListMapOutput values. // You can construct a concrete instance of `RoleListMapInput` via: // @@ -167,6 +180,12 @@ func (i RoleListMap) ToRoleListMapOutputWithContext(ctx context.Context) RoleLis return pulumi.ToOutputWithContext(ctx, i).(RoleListMapOutput) } +func (i RoleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleList] { + return pulumix.Output[map[string]*RoleList]{ + OutputState: i.ToRoleListMapOutputWithContext(ctx).OutputState, + } +} + type RoleListOutput struct{ *pulumi.OutputState } func (RoleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RoleListOutput) ToRoleListOutputWithContext(ctx context.Context) RoleLis return o } +func (o RoleListOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleList] { + return pulumix.Output[*RoleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RoleListArrayOutput) ToRoleListArrayOutputWithContext(ctx context.Contex return o } +func (o RoleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleList] { + return pulumix.Output[[]*RoleList]{ + OutputState: o.OutputState, + } +} + func (o RoleListArrayOutput) Index(i pulumi.IntInput) RoleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleList { return vs[0].([]*RoleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RoleListMapOutput) ToRoleListMapOutputWithContext(ctx context.Context) R return o } +func (o RoleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleList] { + return pulumix.Output[map[string]*RoleList]{ + OutputState: o.OutputState, + } +} + func (o RoleListMapOutput) MapIndex(k pulumi.StringInput) RoleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleList { return vs[0].(map[string]*RoleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1/rolePatch.go b/sdk/go/kubernetes/rbac/v1/rolePatch.go index cb6074d4ba..93fc29ff8b 100644 --- a/sdk/go/kubernetes/rbac/v1/rolePatch.go +++ b/sdk/go/kubernetes/rbac/v1/rolePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -128,6 +129,12 @@ func (i *RolePatch) ToRolePatchOutputWithContext(ctx context.Context) RolePatchO return pulumi.ToOutputWithContext(ctx, i).(RolePatchOutput) } +func (i *RolePatch) ToOutput(ctx context.Context) pulumix.Output[*RolePatch] { + return pulumix.Output[*RolePatch]{ + OutputState: i.ToRolePatchOutputWithContext(ctx).OutputState, + } +} + // RolePatchArrayInput is an input type that accepts RolePatchArray and RolePatchArrayOutput values. // You can construct a concrete instance of `RolePatchArrayInput` via: // @@ -153,6 +160,12 @@ func (i RolePatchArray) ToRolePatchArrayOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RolePatchArrayOutput) } +func (i RolePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RolePatch] { + return pulumix.Output[[]*RolePatch]{ + OutputState: i.ToRolePatchArrayOutputWithContext(ctx).OutputState, + } +} + // RolePatchMapInput is an input type that accepts RolePatchMap and RolePatchMapOutput values. // You can construct a concrete instance of `RolePatchMapInput` via: // @@ -178,6 +191,12 @@ func (i RolePatchMap) ToRolePatchMapOutputWithContext(ctx context.Context) RoleP return pulumi.ToOutputWithContext(ctx, i).(RolePatchMapOutput) } +func (i RolePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RolePatch] { + return pulumix.Output[map[string]*RolePatch]{ + OutputState: i.ToRolePatchMapOutputWithContext(ctx).OutputState, + } +} + type RolePatchOutput struct{ *pulumi.OutputState } func (RolePatchOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o RolePatchOutput) ToRolePatchOutputWithContext(ctx context.Context) RoleP return o } +func (o RolePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RolePatch] { + return pulumix.Output[*RolePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RolePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RolePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o RolePatchArrayOutput) ToRolePatchArrayOutputWithContext(ctx context.Cont return o } +func (o RolePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RolePatch] { + return pulumix.Output[[]*RolePatch]{ + OutputState: o.OutputState, + } +} + func (o RolePatchArrayOutput) Index(i pulumi.IntInput) RolePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RolePatch { return vs[0].([]*RolePatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o RolePatchMapOutput) ToRolePatchMapOutputWithContext(ctx context.Context) return o } +func (o RolePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RolePatch] { + return pulumix.Output[map[string]*RolePatch]{ + OutputState: o.OutputState, + } +} + func (o RolePatchMapOutput) MapIndex(k pulumi.StringInput) RolePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RolePatch { return vs[0].(map[string]*RolePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/clusterRole.go b/sdk/go/kubernetes/rbac/v1alpha1/clusterRole.go index c76f04c86a..5ee49f7d27 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/clusterRole.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/clusterRole.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. @@ -128,6 +129,12 @@ func (i *ClusterRole) ToClusterRoleOutputWithContext(ctx context.Context) Cluste return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleOutput) } +func (i *ClusterRole) ToOutput(ctx context.Context) pulumix.Output[*ClusterRole] { + return pulumix.Output[*ClusterRole]{ + OutputState: i.ToClusterRoleOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleArrayInput is an input type that accepts ClusterRoleArray and ClusterRoleArrayOutput values. // You can construct a concrete instance of `ClusterRoleArrayInput` via: // @@ -153,6 +160,12 @@ func (i ClusterRoleArray) ToClusterRoleArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleArrayOutput) } +func (i ClusterRoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRole] { + return pulumix.Output[[]*ClusterRole]{ + OutputState: i.ToClusterRoleArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleMapInput is an input type that accepts ClusterRoleMap and ClusterRoleMapOutput values. // You can construct a concrete instance of `ClusterRoleMapInput` via: // @@ -178,6 +191,12 @@ func (i ClusterRoleMap) ToClusterRoleMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleMapOutput) } +func (i ClusterRoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRole] { + return pulumix.Output[map[string]*ClusterRole]{ + OutputState: i.ToClusterRoleMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleOutput struct{ *pulumi.OutputState } func (ClusterRoleOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o ClusterRoleOutput) ToClusterRoleOutputWithContext(ctx context.Context) C return o } +func (o ClusterRoleOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRole] { + return pulumix.Output[*ClusterRole]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRoleOutput) AggregationRule() AggregationRuleOutput { return o.ApplyT(func(v *ClusterRole) AggregationRuleOutput { return v.AggregationRule }).(AggregationRuleOutput) @@ -231,6 +256,12 @@ func (o ClusterRoleArrayOutput) ToClusterRoleArrayOutputWithContext(ctx context. return o } +func (o ClusterRoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRole] { + return pulumix.Output[[]*ClusterRole]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleArrayOutput) Index(i pulumi.IntInput) ClusterRoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRole { return vs[0].([]*ClusterRole)[vs[1].(int)] @@ -251,6 +282,12 @@ func (o ClusterRoleMapOutput) ToClusterRoleMapOutputWithContext(ctx context.Cont return o } +func (o ClusterRoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRole] { + return pulumix.Output[map[string]*ClusterRole]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRole { return vs[0].(map[string]*ClusterRole)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBinding.go b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBinding.go index 35f30299f1..5167922cc3 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBinding.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBinding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. @@ -132,6 +133,12 @@ func (i *ClusterRoleBinding) ToClusterRoleBindingOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingOutput) } +func (i *ClusterRoleBinding) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBinding] { + return pulumix.Output[*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingArrayInput is an input type that accepts ClusterRoleBindingArray and ClusterRoleBindingArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingArrayInput` via: // @@ -157,6 +164,12 @@ func (i ClusterRoleBindingArray) ToClusterRoleBindingArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingArrayOutput) } +func (i ClusterRoleBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBinding] { + return pulumix.Output[[]*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingMapInput is an input type that accepts ClusterRoleBindingMap and ClusterRoleBindingMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingMapInput` via: // @@ -182,6 +195,12 @@ func (i ClusterRoleBindingMap) ToClusterRoleBindingMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingMapOutput) } +func (i ClusterRoleBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBinding] { + return pulumix.Output[map[string]*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o ClusterRoleBindingOutput) ToClusterRoleBindingOutputWithContext(ctx cont return o } +func (o ClusterRoleBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBinding] { + return pulumix.Output[*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o ClusterRoleBindingArrayOutput) ToClusterRoleBindingArrayOutputWithContex return o } +func (o ClusterRoleBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBinding] { + return pulumix.Output[[]*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBinding { return vs[0].([]*ClusterRoleBinding)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o ClusterRoleBindingMapOutput) ToClusterRoleBindingMapOutputWithContext(ct return o } +func (o ClusterRoleBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBinding] { + return pulumix.Output[map[string]*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBinding { return vs[0].(map[string]*ClusterRoleBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingList.go b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingList.go index b5e6a851ea..7491b49675 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingList.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindings, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *ClusterRoleBindingList) ToClusterRoleBindingListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListOutput) } +func (i *ClusterRoleBindingList) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingList] { + return pulumix.Output[*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingListArrayInput is an input type that accepts ClusterRoleBindingListArray and ClusterRoleBindingListArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterRoleBindingListArray) ToClusterRoleBindingListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListArrayOutput) } +func (i ClusterRoleBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingList] { + return pulumix.Output[[]*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingListMapInput is an input type that accepts ClusterRoleBindingListMap and ClusterRoleBindingListMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterRoleBindingListMap) ToClusterRoleBindingListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListMapOutput) } +func (i ClusterRoleBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingList] { + return pulumix.Output[map[string]*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingListOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterRoleBindingListOutput) ToClusterRoleBindingListOutputWithContext( return o } +func (o ClusterRoleBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingList] { + return pulumix.Output[*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterRoleBindingListArrayOutput) ToClusterRoleBindingListArrayOutputWi return o } +func (o ClusterRoleBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingList] { + return pulumix.Output[[]*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingListArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBindingList { return vs[0].([]*ClusterRoleBindingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterRoleBindingListMapOutput) ToClusterRoleBindingListMapOutputWithCo return o } +func (o ClusterRoleBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingList] { + return pulumix.Output[map[string]*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingListMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBindingList { return vs[0].(map[string]*ClusterRoleBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingPatch.go b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingPatch.go index c9593a1dea..e887f12c8e 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingPatch.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ClusterRoleBindingPatch) ToClusterRoleBindingPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchOutput) } +func (i *ClusterRoleBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingPatch] { + return pulumix.Output[*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingPatchArrayInput is an input type that accepts ClusterRoleBindingPatchArray and ClusterRoleBindingPatchArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ClusterRoleBindingPatchArray) ToClusterRoleBindingPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchArrayOutput) } +func (i ClusterRoleBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingPatch] { + return pulumix.Output[[]*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingPatchMapInput is an input type that accepts ClusterRoleBindingPatchMap and ClusterRoleBindingPatchMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ClusterRoleBindingPatchMap) ToClusterRoleBindingPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchMapOutput) } +func (i ClusterRoleBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingPatch] { + return pulumix.Output[map[string]*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingPatchOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ClusterRoleBindingPatchOutput) ToClusterRoleBindingPatchOutputWithContex return o } +func (o ClusterRoleBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingPatch] { + return pulumix.Output[*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ClusterRoleBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o ClusterRoleBindingPatchArrayOutput) ToClusterRoleBindingPatchArrayOutput return o } +func (o ClusterRoleBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingPatch] { + return pulumix.Output[[]*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingPatchArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBindingPatch { return vs[0].([]*ClusterRoleBindingPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ClusterRoleBindingPatchMapOutput) ToClusterRoleBindingPatchMapOutputWith return o } +func (o ClusterRoleBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingPatch] { + return pulumix.Output[map[string]*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingPatchMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBindingPatch { return vs[0].(map[string]*ClusterRoleBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleList.go b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleList.go index c457fe68d5..736c53218b 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleList.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/clusterRoleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleList is a collection of ClusterRoles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoles, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *ClusterRoleList) ToClusterRoleListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListOutput) } +func (i *ClusterRoleList) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleList] { + return pulumix.Output[*ClusterRoleList]{ + OutputState: i.ToClusterRoleListOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleListArrayInput is an input type that accepts ClusterRoleListArray and ClusterRoleListArrayOutput values. // You can construct a concrete instance of `ClusterRoleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterRoleListArray) ToClusterRoleListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListArrayOutput) } +func (i ClusterRoleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleList] { + return pulumix.Output[[]*ClusterRoleList]{ + OutputState: i.ToClusterRoleListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleListMapInput is an input type that accepts ClusterRoleListMap and ClusterRoleListMapOutput values. // You can construct a concrete instance of `ClusterRoleListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterRoleListMap) ToClusterRoleListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListMapOutput) } +func (i ClusterRoleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleList] { + return pulumix.Output[map[string]*ClusterRoleList]{ + OutputState: i.ToClusterRoleListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleListOutput struct{ *pulumi.OutputState } func (ClusterRoleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterRoleListOutput) ToClusterRoleListOutputWithContext(ctx context.Co return o } +func (o ClusterRoleListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleList] { + return pulumix.Output[*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterRoleListArrayOutput) ToClusterRoleListArrayOutputWithContext(ctx return o } +func (o ClusterRoleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleList] { + return pulumix.Output[[]*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleListArrayOutput) Index(i pulumi.IntInput) ClusterRoleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleList { return vs[0].([]*ClusterRoleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterRoleListMapOutput) ToClusterRoleListMapOutputWithContext(ctx cont return o } +func (o ClusterRoleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleList] { + return pulumix.Output[map[string]*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleListMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleList { return vs[0].(map[string]*ClusterRoleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/clusterRolePatch.go b/sdk/go/kubernetes/rbac/v1alpha1/clusterRolePatch.go index de7ba747a2..0314e352f3 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/clusterRolePatch.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/clusterRolePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ClusterRolePatch) ToClusterRolePatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchOutput) } +func (i *ClusterRolePatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterRolePatch] { + return pulumix.Output[*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchOutputWithContext(ctx).OutputState, + } +} + // ClusterRolePatchArrayInput is an input type that accepts ClusterRolePatchArray and ClusterRolePatchArrayOutput values. // You can construct a concrete instance of `ClusterRolePatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ClusterRolePatchArray) ToClusterRolePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchArrayOutput) } +func (i ClusterRolePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRolePatch] { + return pulumix.Output[[]*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRolePatchMapInput is an input type that accepts ClusterRolePatchMap and ClusterRolePatchMapOutput values. // You can construct a concrete instance of `ClusterRolePatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ClusterRolePatchMap) ToClusterRolePatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchMapOutput) } +func (i ClusterRolePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRolePatch] { + return pulumix.Output[map[string]*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRolePatchOutput struct{ *pulumi.OutputState } func (ClusterRolePatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ClusterRolePatchOutput) ToClusterRolePatchOutputWithContext(ctx context. return o } +func (o ClusterRolePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRolePatch] { + return pulumix.Output[*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRolePatchOutput) AggregationRule() AggregationRulePatchPtrOutput { return o.ApplyT(func(v *ClusterRolePatch) AggregationRulePatchPtrOutput { return v.AggregationRule }).(AggregationRulePatchPtrOutput) @@ -237,6 +262,12 @@ func (o ClusterRolePatchArrayOutput) ToClusterRolePatchArrayOutputWithContext(ct return o } +func (o ClusterRolePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRolePatch] { + return pulumix.Output[[]*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRolePatchArrayOutput) Index(i pulumi.IntInput) ClusterRolePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRolePatch { return vs[0].([]*ClusterRolePatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ClusterRolePatchMapOutput) ToClusterRolePatchMapOutputWithContext(ctx co return o } +func (o ClusterRolePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRolePatch] { + return pulumix.Output[map[string]*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRolePatchMapOutput) MapIndex(k pulumi.StringInput) ClusterRolePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRolePatch { return vs[0].(map[string]*ClusterRolePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/rbac/v1alpha1/pulumiTypes.go index 081a8411f4..416043db57 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -49,6 +50,12 @@ func (i AggregationRuleArgs) ToAggregationRuleOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AggregationRuleOutput) } +func (i AggregationRuleArgs) ToOutput(ctx context.Context) pulumix.Output[AggregationRule] { + return pulumix.Output[AggregationRule]{ + OutputState: i.ToAggregationRuleOutputWithContext(ctx).OutputState, + } +} + func (i AggregationRuleArgs) ToAggregationRulePtrOutput() AggregationRulePtrOutput { return i.ToAggregationRulePtrOutputWithContext(context.Background()) } @@ -90,6 +97,12 @@ func (i *aggregationRulePtrType) ToAggregationRulePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePtrOutput) } +func (i *aggregationRulePtrType) ToOutput(ctx context.Context) pulumix.Output[*AggregationRule] { + return pulumix.Output[*AggregationRule]{ + OutputState: i.ToAggregationRulePtrOutputWithContext(ctx).OutputState, + } +} + // AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole type AggregationRuleOutput struct{ *pulumi.OutputState } @@ -115,6 +128,12 @@ func (o AggregationRuleOutput) ToAggregationRulePtrOutputWithContext(ctx context }).(AggregationRulePtrOutput) } +func (o AggregationRuleOutput) ToOutput(ctx context.Context) pulumix.Output[AggregationRule] { + return pulumix.Output[AggregationRule]{ + OutputState: o.OutputState, + } +} + // ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added func (o AggregationRuleOutput) ClusterRoleSelectors() metav1.LabelSelectorArrayOutput { return o.ApplyT(func(v AggregationRule) []metav1.LabelSelector { return v.ClusterRoleSelectors }).(metav1.LabelSelectorArrayOutput) @@ -134,6 +153,12 @@ func (o AggregationRulePtrOutput) ToAggregationRulePtrOutputWithContext(ctx cont return o } +func (o AggregationRulePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AggregationRule] { + return pulumix.Output[*AggregationRule]{ + OutputState: o.OutputState, + } +} + func (o AggregationRulePtrOutput) Elem() AggregationRuleOutput { return o.ApplyT(func(v *AggregationRule) AggregationRule { if v != nil { @@ -189,6 +214,12 @@ func (i AggregationRulePatchArgs) ToAggregationRulePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePatchOutput) } +func (i AggregationRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AggregationRulePatch] { + return pulumix.Output[AggregationRulePatch]{ + OutputState: i.ToAggregationRulePatchOutputWithContext(ctx).OutputState, + } +} + func (i AggregationRulePatchArgs) ToAggregationRulePatchPtrOutput() AggregationRulePatchPtrOutput { return i.ToAggregationRulePatchPtrOutputWithContext(context.Background()) } @@ -230,6 +261,12 @@ func (i *aggregationRulePatchPtrType) ToAggregationRulePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePatchPtrOutput) } +func (i *aggregationRulePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AggregationRulePatch] { + return pulumix.Output[*AggregationRulePatch]{ + OutputState: i.ToAggregationRulePatchPtrOutputWithContext(ctx).OutputState, + } +} + // AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole type AggregationRulePatchOutput struct{ *pulumi.OutputState } @@ -255,6 +292,12 @@ func (o AggregationRulePatchOutput) ToAggregationRulePatchPtrOutputWithContext(c }).(AggregationRulePatchPtrOutput) } +func (o AggregationRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AggregationRulePatch] { + return pulumix.Output[AggregationRulePatch]{ + OutputState: o.OutputState, + } +} + // ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added func (o AggregationRulePatchOutput) ClusterRoleSelectors() metav1.LabelSelectorPatchArrayOutput { return o.ApplyT(func(v AggregationRulePatch) []metav1.LabelSelectorPatch { return v.ClusterRoleSelectors }).(metav1.LabelSelectorPatchArrayOutput) @@ -274,6 +317,12 @@ func (o AggregationRulePatchPtrOutput) ToAggregationRulePatchPtrOutputWithContex return o } +func (o AggregationRulePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AggregationRulePatch] { + return pulumix.Output[*AggregationRulePatch]{ + OutputState: o.OutputState, + } +} + func (o AggregationRulePatchPtrOutput) Elem() AggregationRulePatchOutput { return o.ApplyT(func(v *AggregationRulePatch) AggregationRulePatch { if v != nil { @@ -345,6 +394,12 @@ func (i ClusterRoleTypeArgs) ToClusterRoleTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleTypeOutput) } +func (i ClusterRoleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleType] { + return pulumix.Output[ClusterRoleType]{ + OutputState: i.ToClusterRoleTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleTypeArrayInput is an input type that accepts ClusterRoleTypeArray and ClusterRoleTypeArrayOutput values. // You can construct a concrete instance of `ClusterRoleTypeArrayInput` via: // @@ -370,6 +425,12 @@ func (i ClusterRoleTypeArray) ToClusterRoleTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleTypeArrayOutput) } +func (i ClusterRoleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleType] { + return pulumix.Output[[]ClusterRoleType]{ + OutputState: i.ToClusterRoleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. type ClusterRoleTypeOutput struct{ *pulumi.OutputState } @@ -385,6 +446,12 @@ func (o ClusterRoleTypeOutput) ToClusterRoleTypeOutputWithContext(ctx context.Co return o } +func (o ClusterRoleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleType] { + return pulumix.Output[ClusterRoleType]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRoleTypeOutput) AggregationRule() AggregationRulePtrOutput { return o.ApplyT(func(v ClusterRoleType) *AggregationRule { return v.AggregationRule }).(AggregationRulePtrOutput) @@ -424,6 +491,12 @@ func (o ClusterRoleTypeArrayOutput) ToClusterRoleTypeArrayOutputWithContext(ctx return o } +func (o ClusterRoleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleType] { + return pulumix.Output[[]ClusterRoleType]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleTypeArrayOutput) Index(i pulumi.IntInput) ClusterRoleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterRoleType { return vs[0].([]ClusterRoleType)[vs[1].(int)] @@ -481,6 +554,12 @@ func (i ClusterRoleBindingTypeArgs) ToClusterRoleBindingTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingTypeOutput) } +func (i ClusterRoleBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingType] { + return pulumix.Output[ClusterRoleBindingType]{ + OutputState: i.ToClusterRoleBindingTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingTypeArrayInput is an input type that accepts ClusterRoleBindingTypeArray and ClusterRoleBindingTypeArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingTypeArrayInput` via: // @@ -506,6 +585,12 @@ func (i ClusterRoleBindingTypeArray) ToClusterRoleBindingTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingTypeArrayOutput) } +func (i ClusterRoleBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleBindingType] { + return pulumix.Output[[]ClusterRoleBindingType]{ + OutputState: i.ToClusterRoleBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. type ClusterRoleBindingTypeOutput struct{ *pulumi.OutputState } @@ -521,6 +606,12 @@ func (o ClusterRoleBindingTypeOutput) ToClusterRoleBindingTypeOutputWithContext( return o } +func (o ClusterRoleBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingType] { + return pulumix.Output[ClusterRoleBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -560,6 +651,12 @@ func (o ClusterRoleBindingTypeArrayOutput) ToClusterRoleBindingTypeArrayOutputWi return o } +func (o ClusterRoleBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleBindingType] { + return pulumix.Output[[]ClusterRoleBindingType]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingTypeArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterRoleBindingType { return vs[0].([]ClusterRoleBindingType)[vs[1].(int)] @@ -613,6 +710,12 @@ func (i ClusterRoleBindingListTypeArgs) ToClusterRoleBindingListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListTypeOutput) } +func (i ClusterRoleBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingListType] { + return pulumix.Output[ClusterRoleBindingListType]{ + OutputState: i.ToClusterRoleBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindings, and will no longer be served in v1.20. type ClusterRoleBindingListTypeOutput struct{ *pulumi.OutputState } @@ -628,6 +731,12 @@ func (o ClusterRoleBindingListTypeOutput) ToClusterRoleBindingListTypeOutputWith return o } +func (o ClusterRoleBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingListType] { + return pulumix.Output[ClusterRoleBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -699,6 +808,12 @@ func (i ClusterRoleBindingPatchTypeArgs) ToClusterRoleBindingPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchTypeOutput) } +func (i ClusterRoleBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingPatchType] { + return pulumix.Output[ClusterRoleBindingPatchType]{ + OutputState: i.ToClusterRoleBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. type ClusterRoleBindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -714,6 +829,12 @@ func (o ClusterRoleBindingPatchTypeOutput) ToClusterRoleBindingPatchTypeOutputWi return o } +func (o ClusterRoleBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingPatchType] { + return pulumix.Output[ClusterRoleBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -786,6 +907,12 @@ func (i ClusterRoleListTypeArgs) ToClusterRoleListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListTypeOutput) } +func (i ClusterRoleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleListType] { + return pulumix.Output[ClusterRoleListType]{ + OutputState: i.ToClusterRoleListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleList is a collection of ClusterRoles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoles, and will no longer be served in v1.20. type ClusterRoleListTypeOutput struct{ *pulumi.OutputState } @@ -801,6 +928,12 @@ func (o ClusterRoleListTypeOutput) ToClusterRoleListTypeOutputWithContext(ctx co return o } +func (o ClusterRoleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleListType] { + return pulumix.Output[ClusterRoleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -872,6 +1005,12 @@ func (i ClusterRolePatchTypeArgs) ToClusterRolePatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchTypeOutput) } +func (i ClusterRolePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRolePatchType] { + return pulumix.Output[ClusterRolePatchType]{ + OutputState: i.ToClusterRolePatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. type ClusterRolePatchTypeOutput struct{ *pulumi.OutputState } @@ -887,6 +1026,12 @@ func (o ClusterRolePatchTypeOutput) ToClusterRolePatchTypeOutputWithContext(ctx return o } +func (o ClusterRolePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRolePatchType] { + return pulumix.Output[ClusterRolePatchType]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRolePatchTypeOutput) AggregationRule() AggregationRulePatchPtrOutput { return o.ApplyT(func(v ClusterRolePatchType) *AggregationRulePatch { return v.AggregationRule }).(AggregationRulePatchPtrOutput) @@ -963,6 +1108,12 @@ func (i PolicyRuleArgs) ToPolicyRuleOutputWithContext(ctx context.Context) Polic return pulumi.ToOutputWithContext(ctx, i).(PolicyRuleOutput) } +func (i PolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRule] { + return pulumix.Output[PolicyRule]{ + OutputState: i.ToPolicyRuleOutputWithContext(ctx).OutputState, + } +} + // PolicyRuleArrayInput is an input type that accepts PolicyRuleArray and PolicyRuleArrayOutput values. // You can construct a concrete instance of `PolicyRuleArrayInput` via: // @@ -988,6 +1139,12 @@ func (i PolicyRuleArray) ToPolicyRuleArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PolicyRuleArrayOutput) } +func (i PolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRule] { + return pulumix.Output[[]PolicyRule]{ + OutputState: i.ToPolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. type PolicyRuleOutput struct{ *pulumi.OutputState } @@ -1003,6 +1160,12 @@ func (o PolicyRuleOutput) ToPolicyRuleOutputWithContext(ctx context.Context) Pol return o } +func (o PolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRule] { + return pulumix.Output[PolicyRule]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. func (o PolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v PolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1042,6 +1205,12 @@ func (o PolicyRuleArrayOutput) ToPolicyRuleArrayOutputWithContext(ctx context.Co return o } +func (o PolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRule] { + return pulumix.Output[[]PolicyRule]{ + OutputState: o.OutputState, + } +} + func (o PolicyRuleArrayOutput) Index(i pulumi.IntInput) PolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRule { return vs[0].([]PolicyRule)[vs[1].(int)] @@ -1099,6 +1268,12 @@ func (i PolicyRulePatchArgs) ToPolicyRulePatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PolicyRulePatchOutput) } +func (i PolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulePatch] { + return pulumix.Output[PolicyRulePatch]{ + OutputState: i.ToPolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulePatchArrayInput is an input type that accepts PolicyRulePatchArray and PolicyRulePatchArrayOutput values. // You can construct a concrete instance of `PolicyRulePatchArrayInput` via: // @@ -1124,6 +1299,12 @@ func (i PolicyRulePatchArray) ToPolicyRulePatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PolicyRulePatchArrayOutput) } +func (i PolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulePatch] { + return pulumix.Output[[]PolicyRulePatch]{ + OutputState: i.ToPolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. type PolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -1139,6 +1320,12 @@ func (o PolicyRulePatchOutput) ToPolicyRulePatchOutputWithContext(ctx context.Co return o } +func (o PolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulePatch] { + return pulumix.Output[PolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. func (o PolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v PolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1178,6 +1365,12 @@ func (o PolicyRulePatchArrayOutput) ToPolicyRulePatchArrayOutputWithContext(ctx return o } +func (o PolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulePatch] { + return pulumix.Output[[]PolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulePatchArrayOutput) Index(i pulumi.IntInput) PolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulePatch { return vs[0].([]PolicyRulePatch)[vs[1].(int)] @@ -1231,6 +1424,12 @@ func (i RoleTypeArgs) ToRoleTypeOutputWithContext(ctx context.Context) RoleTypeO return pulumi.ToOutputWithContext(ctx, i).(RoleTypeOutput) } +func (i RoleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleType] { + return pulumix.Output[RoleType]{ + OutputState: i.ToRoleTypeOutputWithContext(ctx).OutputState, + } +} + // RoleTypeArrayInput is an input type that accepts RoleTypeArray and RoleTypeArrayOutput values. // You can construct a concrete instance of `RoleTypeArrayInput` via: // @@ -1256,6 +1455,12 @@ func (i RoleTypeArray) ToRoleTypeArrayOutputWithContext(ctx context.Context) Rol return pulumi.ToOutputWithContext(ctx, i).(RoleTypeArrayOutput) } +func (i RoleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RoleType] { + return pulumix.Output[[]RoleType]{ + OutputState: i.ToRoleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. type RoleTypeOutput struct{ *pulumi.OutputState } @@ -1271,6 +1476,12 @@ func (o RoleTypeOutput) ToRoleTypeOutputWithContext(ctx context.Context) RoleTyp return o } +func (o RoleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleType] { + return pulumix.Output[RoleType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1305,6 +1516,12 @@ func (o RoleTypeArrayOutput) ToRoleTypeArrayOutputWithContext(ctx context.Contex return o } +func (o RoleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RoleType] { + return pulumix.Output[[]RoleType]{ + OutputState: o.OutputState, + } +} + func (o RoleTypeArrayOutput) Index(i pulumi.IntInput) RoleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RoleType { return vs[0].([]RoleType)[vs[1].(int)] @@ -1362,6 +1579,12 @@ func (i RoleBindingTypeArgs) ToRoleBindingTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingTypeOutput) } +func (i RoleBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingType] { + return pulumix.Output[RoleBindingType]{ + OutputState: i.ToRoleBindingTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBindingTypeArrayInput is an input type that accepts RoleBindingTypeArray and RoleBindingTypeArrayOutput values. // You can construct a concrete instance of `RoleBindingTypeArrayInput` via: // @@ -1387,6 +1610,12 @@ func (i RoleBindingTypeArray) ToRoleBindingTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingTypeArrayOutput) } +func (i RoleBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RoleBindingType] { + return pulumix.Output[[]RoleBindingType]{ + OutputState: i.ToRoleBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. type RoleBindingTypeOutput struct{ *pulumi.OutputState } @@ -1402,6 +1631,12 @@ func (o RoleBindingTypeOutput) ToRoleBindingTypeOutputWithContext(ctx context.Co return o } +func (o RoleBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingType] { + return pulumix.Output[RoleBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1441,6 +1676,12 @@ func (o RoleBindingTypeArrayOutput) ToRoleBindingTypeArrayOutputWithContext(ctx return o } +func (o RoleBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RoleBindingType] { + return pulumix.Output[[]RoleBindingType]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingTypeArrayOutput) Index(i pulumi.IntInput) RoleBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RoleBindingType { return vs[0].([]RoleBindingType)[vs[1].(int)] @@ -1494,6 +1735,12 @@ func (i RoleBindingListTypeArgs) ToRoleBindingListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListTypeOutput) } +func (i RoleBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingListType] { + return pulumix.Output[RoleBindingListType]{ + OutputState: i.ToRoleBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBindingList is a collection of RoleBindings Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBindingList, and will no longer be served in v1.20. type RoleBindingListTypeOutput struct{ *pulumi.OutputState } @@ -1509,6 +1756,12 @@ func (o RoleBindingListTypeOutput) ToRoleBindingListTypeOutputWithContext(ctx co return o } +func (o RoleBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingListType] { + return pulumix.Output[RoleBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1580,6 +1833,12 @@ func (i RoleBindingPatchTypeArgs) ToRoleBindingPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchTypeOutput) } +func (i RoleBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingPatchType] { + return pulumix.Output[RoleBindingPatchType]{ + OutputState: i.ToRoleBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. type RoleBindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -1595,6 +1854,12 @@ func (o RoleBindingPatchTypeOutput) ToRoleBindingPatchTypeOutputWithContext(ctx return o } +func (o RoleBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingPatchType] { + return pulumix.Output[RoleBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1667,6 +1932,12 @@ func (i RoleListTypeArgs) ToRoleListTypeOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleListTypeOutput) } +func (i RoleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleListType] { + return pulumix.Output[RoleListType]{ + OutputState: i.ToRoleListTypeOutputWithContext(ctx).OutputState, + } +} + // RoleList is a collection of Roles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleList, and will no longer be served in v1.20. type RoleListTypeOutput struct{ *pulumi.OutputState } @@ -1682,6 +1953,12 @@ func (o RoleListTypeOutput) ToRoleListTypeOutputWithContext(ctx context.Context) return o } +func (o RoleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleListType] { + return pulumix.Output[RoleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1749,6 +2026,12 @@ func (i RolePatchTypeArgs) ToRolePatchTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(RolePatchTypeOutput) } +func (i RolePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RolePatchType] { + return pulumix.Output[RolePatchType]{ + OutputState: i.ToRolePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. type RolePatchTypeOutput struct{ *pulumi.OutputState } @@ -1764,6 +2047,12 @@ func (o RolePatchTypeOutput) ToRolePatchTypeOutputWithContext(ctx context.Contex return o } +func (o RolePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RolePatchType] { + return pulumix.Output[RolePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RolePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RolePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1827,6 +2116,12 @@ func (i RoleRefArgs) ToRoleRefOutputWithContext(ctx context.Context) RoleRefOutp return pulumi.ToOutputWithContext(ctx, i).(RoleRefOutput) } +func (i RoleRefArgs) ToOutput(ctx context.Context) pulumix.Output[RoleRef] { + return pulumix.Output[RoleRef]{ + OutputState: i.ToRoleRefOutputWithContext(ctx).OutputState, + } +} + // RoleRef contains information that points to the role being used type RoleRefOutput struct{ *pulumi.OutputState } @@ -1842,6 +2137,12 @@ func (o RoleRefOutput) ToRoleRefOutputWithContext(ctx context.Context) RoleRefOu return o } +func (o RoleRefOutput) ToOutput(ctx context.Context) pulumix.Output[RoleRef] { + return pulumix.Output[RoleRef]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced func (o RoleRefOutput) ApiGroup() pulumi.StringOutput { return o.ApplyT(func(v RoleRef) string { return v.ApiGroup }).(pulumi.StringOutput) @@ -1900,6 +2201,12 @@ func (i RoleRefPatchArgs) ToRoleRefPatchOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleRefPatchOutput) } +func (i RoleRefPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RoleRefPatch] { + return pulumix.Output[RoleRefPatch]{ + OutputState: i.ToRoleRefPatchOutputWithContext(ctx).OutputState, + } +} + func (i RoleRefPatchArgs) ToRoleRefPatchPtrOutput() RoleRefPatchPtrOutput { return i.ToRoleRefPatchPtrOutputWithContext(context.Background()) } @@ -1941,6 +2248,12 @@ func (i *roleRefPatchPtrType) ToRoleRefPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(RoleRefPatchPtrOutput) } +func (i *roleRefPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RoleRefPatch] { + return pulumix.Output[*RoleRefPatch]{ + OutputState: i.ToRoleRefPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RoleRef contains information that points to the role being used type RoleRefPatchOutput struct{ *pulumi.OutputState } @@ -1966,6 +2279,12 @@ func (o RoleRefPatchOutput) ToRoleRefPatchPtrOutputWithContext(ctx context.Conte }).(RoleRefPatchPtrOutput) } +func (o RoleRefPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RoleRefPatch] { + return pulumix.Output[RoleRefPatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced func (o RoleRefPatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleRefPatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1995,6 +2314,12 @@ func (o RoleRefPatchPtrOutput) ToRoleRefPatchPtrOutputWithContext(ctx context.Co return o } +func (o RoleRefPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleRefPatch] { + return pulumix.Output[*RoleRefPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleRefPatchPtrOutput) Elem() RoleRefPatchOutput { return o.ApplyT(func(v *RoleRefPatch) RoleRefPatch { if v != nil { @@ -2082,6 +2407,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -2107,6 +2438,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. type SubjectOutput struct{ *pulumi.OutputState } @@ -2122,6 +2459,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + // APIVersion holds the API group and version of the referenced subject. Defaults to "v1" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io/v1alpha1" for User and Group subjects. func (o SubjectOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v Subject) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2156,6 +2499,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -2209,6 +2558,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -2234,6 +2589,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -2249,6 +2610,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion holds the API group and version of the referenced subject. Defaults to "v1" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io/v1alpha1" for User and Group subjects. func (o SubjectPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2283,6 +2650,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/role.go b/sdk/go/kubernetes/rbac/v1alpha1/role.go index a9e2410112..a5142ad1a0 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/role.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/role.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. @@ -122,6 +123,12 @@ func (i *Role) ToRoleOutputWithContext(ctx context.Context) RoleOutput { return pulumi.ToOutputWithContext(ctx, i).(RoleOutput) } +func (i *Role) ToOutput(ctx context.Context) pulumix.Output[*Role] { + return pulumix.Output[*Role]{ + OutputState: i.ToRoleOutputWithContext(ctx).OutputState, + } +} + // RoleArrayInput is an input type that accepts RoleArray and RoleArrayOutput values. // You can construct a concrete instance of `RoleArrayInput` via: // @@ -147,6 +154,12 @@ func (i RoleArray) ToRoleArrayOutputWithContext(ctx context.Context) RoleArrayOu return pulumi.ToOutputWithContext(ctx, i).(RoleArrayOutput) } +func (i RoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*Role] { + return pulumix.Output[[]*Role]{ + OutputState: i.ToRoleArrayOutputWithContext(ctx).OutputState, + } +} + // RoleMapInput is an input type that accepts RoleMap and RoleMapOutput values. // You can construct a concrete instance of `RoleMapInput` via: // @@ -172,6 +185,12 @@ func (i RoleMap) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOutput { return pulumi.ToOutputWithContext(ctx, i).(RoleMapOutput) } +func (i RoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Role] { + return pulumix.Output[map[string]*Role]{ + OutputState: i.ToRoleMapOutputWithContext(ctx).OutputState, + } +} + type RoleOutput struct{ *pulumi.OutputState } func (RoleOutput) ElementType() reflect.Type { @@ -186,6 +205,12 @@ func (o RoleOutput) ToRoleOutputWithContext(ctx context.Context) RoleOutput { return o } +func (o RoleOutput) ToOutput(ctx context.Context) pulumix.Output[*Role] { + return pulumix.Output[*Role]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Role) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -220,6 +245,12 @@ func (o RoleArrayOutput) ToRoleArrayOutputWithContext(ctx context.Context) RoleA return o } +func (o RoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Role] { + return pulumix.Output[[]*Role]{ + OutputState: o.OutputState, + } +} + func (o RoleArrayOutput) Index(i pulumi.IntInput) RoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Role { return vs[0].([]*Role)[vs[1].(int)] @@ -240,6 +271,12 @@ func (o RoleMapOutput) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOu return o } +func (o RoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Role] { + return pulumix.Output[map[string]*Role]{ + OutputState: o.OutputState, + } +} + func (o RoleMapOutput) MapIndex(k pulumi.StringInput) RoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Role { return vs[0].(map[string]*Role)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/roleBinding.go b/sdk/go/kubernetes/rbac/v1alpha1/roleBinding.go index e7edf7342f..d02d2d2619 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/roleBinding.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/roleBinding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. @@ -132,6 +133,12 @@ func (i *RoleBinding) ToRoleBindingOutputWithContext(ctx context.Context) RoleBi return pulumi.ToOutputWithContext(ctx, i).(RoleBindingOutput) } +func (i *RoleBinding) ToOutput(ctx context.Context) pulumix.Output[*RoleBinding] { + return pulumix.Output[*RoleBinding]{ + OutputState: i.ToRoleBindingOutputWithContext(ctx).OutputState, + } +} + // RoleBindingArrayInput is an input type that accepts RoleBindingArray and RoleBindingArrayOutput values. // You can construct a concrete instance of `RoleBindingArrayInput` via: // @@ -157,6 +164,12 @@ func (i RoleBindingArray) ToRoleBindingArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingArrayOutput) } +func (i RoleBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBinding] { + return pulumix.Output[[]*RoleBinding]{ + OutputState: i.ToRoleBindingArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingMapInput is an input type that accepts RoleBindingMap and RoleBindingMapOutput values. // You can construct a concrete instance of `RoleBindingMapInput` via: // @@ -182,6 +195,12 @@ func (i RoleBindingMap) ToRoleBindingMapOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleBindingMapOutput) } +func (i RoleBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBinding] { + return pulumix.Output[map[string]*RoleBinding]{ + OutputState: i.ToRoleBindingMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingOutput struct{ *pulumi.OutputState } func (RoleBindingOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o RoleBindingOutput) ToRoleBindingOutputWithContext(ctx context.Context) R return o } +func (o RoleBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBinding] { + return pulumix.Output[*RoleBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o RoleBindingArrayOutput) ToRoleBindingArrayOutputWithContext(ctx context. return o } +func (o RoleBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBinding] { + return pulumix.Output[[]*RoleBinding]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingArrayOutput) Index(i pulumi.IntInput) RoleBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBinding { return vs[0].([]*RoleBinding)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o RoleBindingMapOutput) ToRoleBindingMapOutputWithContext(ctx context.Cont return o } +func (o RoleBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBinding] { + return pulumix.Output[map[string]*RoleBinding]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingMapOutput) MapIndex(k pulumi.StringInput) RoleBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBinding { return vs[0].(map[string]*RoleBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/roleBindingList.go b/sdk/go/kubernetes/rbac/v1alpha1/roleBindingList.go index 30a9d9c4c8..ff420e6c74 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/roleBindingList.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/roleBindingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleBindingList is a collection of RoleBindings Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBindingList, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *RoleBindingList) ToRoleBindingListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListOutput) } +func (i *RoleBindingList) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingList] { + return pulumix.Output[*RoleBindingList]{ + OutputState: i.ToRoleBindingListOutputWithContext(ctx).OutputState, + } +} + // RoleBindingListArrayInput is an input type that accepts RoleBindingListArray and RoleBindingListArrayOutput values. // You can construct a concrete instance of `RoleBindingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RoleBindingListArray) ToRoleBindingListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListArrayOutput) } +func (i RoleBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingList] { + return pulumix.Output[[]*RoleBindingList]{ + OutputState: i.ToRoleBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingListMapInput is an input type that accepts RoleBindingListMap and RoleBindingListMapOutput values. // You can construct a concrete instance of `RoleBindingListMapInput` via: // @@ -167,6 +180,12 @@ func (i RoleBindingListMap) ToRoleBindingListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListMapOutput) } +func (i RoleBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingList] { + return pulumix.Output[map[string]*RoleBindingList]{ + OutputState: i.ToRoleBindingListMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingListOutput struct{ *pulumi.OutputState } func (RoleBindingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RoleBindingListOutput) ToRoleBindingListOutputWithContext(ctx context.Co return o } +func (o RoleBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingList] { + return pulumix.Output[*RoleBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RoleBindingListArrayOutput) ToRoleBindingListArrayOutputWithContext(ctx return o } +func (o RoleBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingList] { + return pulumix.Output[[]*RoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingListArrayOutput) Index(i pulumi.IntInput) RoleBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBindingList { return vs[0].([]*RoleBindingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RoleBindingListMapOutput) ToRoleBindingListMapOutputWithContext(ctx cont return o } +func (o RoleBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingList] { + return pulumix.Output[map[string]*RoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingListMapOutput) MapIndex(k pulumi.StringInput) RoleBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBindingList { return vs[0].(map[string]*RoleBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/roleBindingPatch.go b/sdk/go/kubernetes/rbac/v1alpha1/roleBindingPatch.go index d50d1615f6..4450743e1d 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/roleBindingPatch.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/roleBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *RoleBindingPatch) ToRoleBindingPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchOutput) } +func (i *RoleBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingPatch] { + return pulumix.Output[*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchOutputWithContext(ctx).OutputState, + } +} + // RoleBindingPatchArrayInput is an input type that accepts RoleBindingPatchArray and RoleBindingPatchArrayOutput values. // You can construct a concrete instance of `RoleBindingPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i RoleBindingPatchArray) ToRoleBindingPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchArrayOutput) } +func (i RoleBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingPatch] { + return pulumix.Output[[]*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingPatchMapInput is an input type that accepts RoleBindingPatchMap and RoleBindingPatchMapOutput values. // You can construct a concrete instance of `RoleBindingPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i RoleBindingPatchMap) ToRoleBindingPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchMapOutput) } +func (i RoleBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingPatch] { + return pulumix.Output[map[string]*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingPatchOutput struct{ *pulumi.OutputState } func (RoleBindingPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o RoleBindingPatchOutput) ToRoleBindingPatchOutputWithContext(ctx context. return o } +func (o RoleBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingPatch] { + return pulumix.Output[*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RoleBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o RoleBindingPatchArrayOutput) ToRoleBindingPatchArrayOutputWithContext(ct return o } +func (o RoleBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingPatch] { + return pulumix.Output[[]*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingPatchArrayOutput) Index(i pulumi.IntInput) RoleBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBindingPatch { return vs[0].([]*RoleBindingPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o RoleBindingPatchMapOutput) ToRoleBindingPatchMapOutputWithContext(ctx co return o } +func (o RoleBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingPatch] { + return pulumix.Output[map[string]*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingPatchMapOutput) MapIndex(k pulumi.StringInput) RoleBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBindingPatch { return vs[0].(map[string]*RoleBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/roleList.go b/sdk/go/kubernetes/rbac/v1alpha1/roleList.go index a84d91ff17..63d238f8a9 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/roleList.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/roleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleList is a collection of Roles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleList, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *RoleList) ToRoleListOutputWithContext(ctx context.Context) RoleListOutp return pulumi.ToOutputWithContext(ctx, i).(RoleListOutput) } +func (i *RoleList) ToOutput(ctx context.Context) pulumix.Output[*RoleList] { + return pulumix.Output[*RoleList]{ + OutputState: i.ToRoleListOutputWithContext(ctx).OutputState, + } +} + // RoleListArrayInput is an input type that accepts RoleListArray and RoleListArrayOutput values. // You can construct a concrete instance of `RoleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RoleListArray) ToRoleListArrayOutputWithContext(ctx context.Context) Rol return pulumi.ToOutputWithContext(ctx, i).(RoleListArrayOutput) } +func (i RoleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleList] { + return pulumix.Output[[]*RoleList]{ + OutputState: i.ToRoleListArrayOutputWithContext(ctx).OutputState, + } +} + // RoleListMapInput is an input type that accepts RoleListMap and RoleListMapOutput values. // You can construct a concrete instance of `RoleListMapInput` via: // @@ -167,6 +180,12 @@ func (i RoleListMap) ToRoleListMapOutputWithContext(ctx context.Context) RoleLis return pulumi.ToOutputWithContext(ctx, i).(RoleListMapOutput) } +func (i RoleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleList] { + return pulumix.Output[map[string]*RoleList]{ + OutputState: i.ToRoleListMapOutputWithContext(ctx).OutputState, + } +} + type RoleListOutput struct{ *pulumi.OutputState } func (RoleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RoleListOutput) ToRoleListOutputWithContext(ctx context.Context) RoleLis return o } +func (o RoleListOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleList] { + return pulumix.Output[*RoleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RoleListArrayOutput) ToRoleListArrayOutputWithContext(ctx context.Contex return o } +func (o RoleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleList] { + return pulumix.Output[[]*RoleList]{ + OutputState: o.OutputState, + } +} + func (o RoleListArrayOutput) Index(i pulumi.IntInput) RoleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleList { return vs[0].([]*RoleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RoleListMapOutput) ToRoleListMapOutputWithContext(ctx context.Context) R return o } +func (o RoleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleList] { + return pulumix.Output[map[string]*RoleList]{ + OutputState: o.OutputState, + } +} + func (o RoleListMapOutput) MapIndex(k pulumi.StringInput) RoleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleList { return vs[0].(map[string]*RoleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1alpha1/rolePatch.go b/sdk/go/kubernetes/rbac/v1alpha1/rolePatch.go index 43a90f0bf5..d08fedaaac 100644 --- a/sdk/go/kubernetes/rbac/v1alpha1/rolePatch.go +++ b/sdk/go/kubernetes/rbac/v1alpha1/rolePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -128,6 +129,12 @@ func (i *RolePatch) ToRolePatchOutputWithContext(ctx context.Context) RolePatchO return pulumi.ToOutputWithContext(ctx, i).(RolePatchOutput) } +func (i *RolePatch) ToOutput(ctx context.Context) pulumix.Output[*RolePatch] { + return pulumix.Output[*RolePatch]{ + OutputState: i.ToRolePatchOutputWithContext(ctx).OutputState, + } +} + // RolePatchArrayInput is an input type that accepts RolePatchArray and RolePatchArrayOutput values. // You can construct a concrete instance of `RolePatchArrayInput` via: // @@ -153,6 +160,12 @@ func (i RolePatchArray) ToRolePatchArrayOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RolePatchArrayOutput) } +func (i RolePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RolePatch] { + return pulumix.Output[[]*RolePatch]{ + OutputState: i.ToRolePatchArrayOutputWithContext(ctx).OutputState, + } +} + // RolePatchMapInput is an input type that accepts RolePatchMap and RolePatchMapOutput values. // You can construct a concrete instance of `RolePatchMapInput` via: // @@ -178,6 +191,12 @@ func (i RolePatchMap) ToRolePatchMapOutputWithContext(ctx context.Context) RoleP return pulumi.ToOutputWithContext(ctx, i).(RolePatchMapOutput) } +func (i RolePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RolePatch] { + return pulumix.Output[map[string]*RolePatch]{ + OutputState: i.ToRolePatchMapOutputWithContext(ctx).OutputState, + } +} + type RolePatchOutput struct{ *pulumi.OutputState } func (RolePatchOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o RolePatchOutput) ToRolePatchOutputWithContext(ctx context.Context) RoleP return o } +func (o RolePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RolePatch] { + return pulumix.Output[*RolePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RolePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RolePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o RolePatchArrayOutput) ToRolePatchArrayOutputWithContext(ctx context.Cont return o } +func (o RolePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RolePatch] { + return pulumix.Output[[]*RolePatch]{ + OutputState: o.OutputState, + } +} + func (o RolePatchArrayOutput) Index(i pulumi.IntInput) RolePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RolePatch { return vs[0].([]*RolePatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o RolePatchMapOutput) ToRolePatchMapOutputWithContext(ctx context.Context) return o } +func (o RolePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RolePatch] { + return pulumix.Output[map[string]*RolePatch]{ + OutputState: o.OutputState, + } +} + func (o RolePatchMapOutput) MapIndex(k pulumi.StringInput) RolePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RolePatch { return vs[0].(map[string]*RolePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/clusterRole.go b/sdk/go/kubernetes/rbac/v1beta1/clusterRole.go index 14b0847e48..a0c4a761bd 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/clusterRole.go +++ b/sdk/go/kubernetes/rbac/v1beta1/clusterRole.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. @@ -128,6 +129,12 @@ func (i *ClusterRole) ToClusterRoleOutputWithContext(ctx context.Context) Cluste return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleOutput) } +func (i *ClusterRole) ToOutput(ctx context.Context) pulumix.Output[*ClusterRole] { + return pulumix.Output[*ClusterRole]{ + OutputState: i.ToClusterRoleOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleArrayInput is an input type that accepts ClusterRoleArray and ClusterRoleArrayOutput values. // You can construct a concrete instance of `ClusterRoleArrayInput` via: // @@ -153,6 +160,12 @@ func (i ClusterRoleArray) ToClusterRoleArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleArrayOutput) } +func (i ClusterRoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRole] { + return pulumix.Output[[]*ClusterRole]{ + OutputState: i.ToClusterRoleArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleMapInput is an input type that accepts ClusterRoleMap and ClusterRoleMapOutput values. // You can construct a concrete instance of `ClusterRoleMapInput` via: // @@ -178,6 +191,12 @@ func (i ClusterRoleMap) ToClusterRoleMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleMapOutput) } +func (i ClusterRoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRole] { + return pulumix.Output[map[string]*ClusterRole]{ + OutputState: i.ToClusterRoleMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleOutput struct{ *pulumi.OutputState } func (ClusterRoleOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o ClusterRoleOutput) ToClusterRoleOutputWithContext(ctx context.Context) C return o } +func (o ClusterRoleOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRole] { + return pulumix.Output[*ClusterRole]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRoleOutput) AggregationRule() AggregationRuleOutput { return o.ApplyT(func(v *ClusterRole) AggregationRuleOutput { return v.AggregationRule }).(AggregationRuleOutput) @@ -231,6 +256,12 @@ func (o ClusterRoleArrayOutput) ToClusterRoleArrayOutputWithContext(ctx context. return o } +func (o ClusterRoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRole] { + return pulumix.Output[[]*ClusterRole]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleArrayOutput) Index(i pulumi.IntInput) ClusterRoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRole { return vs[0].([]*ClusterRole)[vs[1].(int)] @@ -251,6 +282,12 @@ func (o ClusterRoleMapOutput) ToClusterRoleMapOutputWithContext(ctx context.Cont return o } +func (o ClusterRoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRole] { + return pulumix.Output[map[string]*ClusterRole]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRole { return vs[0].(map[string]*ClusterRole)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBinding.go b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBinding.go index a94c189f1f..0a3b2d6058 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBinding.go +++ b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBinding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. @@ -132,6 +133,12 @@ func (i *ClusterRoleBinding) ToClusterRoleBindingOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingOutput) } +func (i *ClusterRoleBinding) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBinding] { + return pulumix.Output[*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingArrayInput is an input type that accepts ClusterRoleBindingArray and ClusterRoleBindingArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingArrayInput` via: // @@ -157,6 +164,12 @@ func (i ClusterRoleBindingArray) ToClusterRoleBindingArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingArrayOutput) } +func (i ClusterRoleBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBinding] { + return pulumix.Output[[]*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingMapInput is an input type that accepts ClusterRoleBindingMap and ClusterRoleBindingMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingMapInput` via: // @@ -182,6 +195,12 @@ func (i ClusterRoleBindingMap) ToClusterRoleBindingMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingMapOutput) } +func (i ClusterRoleBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBinding] { + return pulumix.Output[map[string]*ClusterRoleBinding]{ + OutputState: i.ToClusterRoleBindingMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o ClusterRoleBindingOutput) ToClusterRoleBindingOutputWithContext(ctx cont return o } +func (o ClusterRoleBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBinding] { + return pulumix.Output[*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o ClusterRoleBindingArrayOutput) ToClusterRoleBindingArrayOutputWithContex return o } +func (o ClusterRoleBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBinding] { + return pulumix.Output[[]*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBinding { return vs[0].([]*ClusterRoleBinding)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o ClusterRoleBindingMapOutput) ToClusterRoleBindingMapOutputWithContext(ct return o } +func (o ClusterRoleBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBinding] { + return pulumix.Output[map[string]*ClusterRoleBinding]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBinding { return vs[0].(map[string]*ClusterRoleBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingList.go b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingList.go index 7b0ff36eca..4cab08dcf7 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingList.go +++ b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindingList, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *ClusterRoleBindingList) ToClusterRoleBindingListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListOutput) } +func (i *ClusterRoleBindingList) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingList] { + return pulumix.Output[*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingListArrayInput is an input type that accepts ClusterRoleBindingListArray and ClusterRoleBindingListArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterRoleBindingListArray) ToClusterRoleBindingListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListArrayOutput) } +func (i ClusterRoleBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingList] { + return pulumix.Output[[]*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingListMapInput is an input type that accepts ClusterRoleBindingListMap and ClusterRoleBindingListMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterRoleBindingListMap) ToClusterRoleBindingListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListMapOutput) } +func (i ClusterRoleBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingList] { + return pulumix.Output[map[string]*ClusterRoleBindingList]{ + OutputState: i.ToClusterRoleBindingListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingListOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterRoleBindingListOutput) ToClusterRoleBindingListOutputWithContext( return o } +func (o ClusterRoleBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingList] { + return pulumix.Output[*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterRoleBindingListArrayOutput) ToClusterRoleBindingListArrayOutputWi return o } +func (o ClusterRoleBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingList] { + return pulumix.Output[[]*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingListArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBindingList { return vs[0].([]*ClusterRoleBindingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterRoleBindingListMapOutput) ToClusterRoleBindingListMapOutputWithCo return o } +func (o ClusterRoleBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingList] { + return pulumix.Output[map[string]*ClusterRoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingListMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBindingList { return vs[0].(map[string]*ClusterRoleBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingPatch.go b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingPatch.go index 94d0c0551a..7121bee170 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingPatch.go +++ b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ClusterRoleBindingPatch) ToClusterRoleBindingPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchOutput) } +func (i *ClusterRoleBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingPatch] { + return pulumix.Output[*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingPatchArrayInput is an input type that accepts ClusterRoleBindingPatchArray and ClusterRoleBindingPatchArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ClusterRoleBindingPatchArray) ToClusterRoleBindingPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchArrayOutput) } +func (i ClusterRoleBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingPatch] { + return pulumix.Output[[]*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingPatchMapInput is an input type that accepts ClusterRoleBindingPatchMap and ClusterRoleBindingPatchMapOutput values. // You can construct a concrete instance of `ClusterRoleBindingPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ClusterRoleBindingPatchMap) ToClusterRoleBindingPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchMapOutput) } +func (i ClusterRoleBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingPatch] { + return pulumix.Output[map[string]*ClusterRoleBindingPatch]{ + OutputState: i.ToClusterRoleBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleBindingPatchOutput struct{ *pulumi.OutputState } func (ClusterRoleBindingPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ClusterRoleBindingPatchOutput) ToClusterRoleBindingPatchOutputWithContex return o } +func (o ClusterRoleBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleBindingPatch] { + return pulumix.Output[*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ClusterRoleBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o ClusterRoleBindingPatchArrayOutput) ToClusterRoleBindingPatchArrayOutput return o } +func (o ClusterRoleBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleBindingPatch] { + return pulumix.Output[[]*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingPatchArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleBindingPatch { return vs[0].([]*ClusterRoleBindingPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ClusterRoleBindingPatchMapOutput) ToClusterRoleBindingPatchMapOutputWith return o } +func (o ClusterRoleBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleBindingPatch] { + return pulumix.Output[map[string]*ClusterRoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingPatchMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleBindingPatch { return vs[0].(map[string]*ClusterRoleBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleList.go b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleList.go index b0edcdf7eb..24ae55e745 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/clusterRoleList.go +++ b/sdk/go/kubernetes/rbac/v1beta1/clusterRoleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ClusterRoleList is a collection of ClusterRoles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoles, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *ClusterRoleList) ToClusterRoleListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListOutput) } +func (i *ClusterRoleList) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleList] { + return pulumix.Output[*ClusterRoleList]{ + OutputState: i.ToClusterRoleListOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleListArrayInput is an input type that accepts ClusterRoleListArray and ClusterRoleListArrayOutput values. // You can construct a concrete instance of `ClusterRoleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ClusterRoleListArray) ToClusterRoleListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListArrayOutput) } +func (i ClusterRoleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleList] { + return pulumix.Output[[]*ClusterRoleList]{ + OutputState: i.ToClusterRoleListArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleListMapInput is an input type that accepts ClusterRoleListMap and ClusterRoleListMapOutput values. // You can construct a concrete instance of `ClusterRoleListMapInput` via: // @@ -167,6 +180,12 @@ func (i ClusterRoleListMap) ToClusterRoleListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListMapOutput) } +func (i ClusterRoleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleList] { + return pulumix.Output[map[string]*ClusterRoleList]{ + OutputState: i.ToClusterRoleListMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRoleListOutput struct{ *pulumi.OutputState } func (ClusterRoleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ClusterRoleListOutput) ToClusterRoleListOutputWithContext(ctx context.Co return o } +func (o ClusterRoleListOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRoleList] { + return pulumix.Output[*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ClusterRoleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ClusterRoleListArrayOutput) ToClusterRoleListArrayOutputWithContext(ctx return o } +func (o ClusterRoleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRoleList] { + return pulumix.Output[[]*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleListArrayOutput) Index(i pulumi.IntInput) ClusterRoleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRoleList { return vs[0].([]*ClusterRoleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ClusterRoleListMapOutput) ToClusterRoleListMapOutputWithContext(ctx cont return o } +func (o ClusterRoleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRoleList] { + return pulumix.Output[map[string]*ClusterRoleList]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleListMapOutput) MapIndex(k pulumi.StringInput) ClusterRoleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRoleList { return vs[0].(map[string]*ClusterRoleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/clusterRolePatch.go b/sdk/go/kubernetes/rbac/v1beta1/clusterRolePatch.go index 226856e7ed..6d595b6652 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/clusterRolePatch.go +++ b/sdk/go/kubernetes/rbac/v1beta1/clusterRolePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *ClusterRolePatch) ToClusterRolePatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchOutput) } +func (i *ClusterRolePatch) ToOutput(ctx context.Context) pulumix.Output[*ClusterRolePatch] { + return pulumix.Output[*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchOutputWithContext(ctx).OutputState, + } +} + // ClusterRolePatchArrayInput is an input type that accepts ClusterRolePatchArray and ClusterRolePatchArrayOutput values. // You can construct a concrete instance of `ClusterRolePatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i ClusterRolePatchArray) ToClusterRolePatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchArrayOutput) } +func (i ClusterRolePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRolePatch] { + return pulumix.Output[[]*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRolePatchMapInput is an input type that accepts ClusterRolePatchMap and ClusterRolePatchMapOutput values. // You can construct a concrete instance of `ClusterRolePatchMapInput` via: // @@ -184,6 +197,12 @@ func (i ClusterRolePatchMap) ToClusterRolePatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchMapOutput) } +func (i ClusterRolePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRolePatch] { + return pulumix.Output[map[string]*ClusterRolePatch]{ + OutputState: i.ToClusterRolePatchMapOutputWithContext(ctx).OutputState, + } +} + type ClusterRolePatchOutput struct{ *pulumi.OutputState } func (ClusterRolePatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o ClusterRolePatchOutput) ToClusterRolePatchOutputWithContext(ctx context. return o } +func (o ClusterRolePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ClusterRolePatch] { + return pulumix.Output[*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRolePatchOutput) AggregationRule() AggregationRulePatchPtrOutput { return o.ApplyT(func(v *ClusterRolePatch) AggregationRulePatchPtrOutput { return v.AggregationRule }).(AggregationRulePatchPtrOutput) @@ -237,6 +262,12 @@ func (o ClusterRolePatchArrayOutput) ToClusterRolePatchArrayOutputWithContext(ct return o } +func (o ClusterRolePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ClusterRolePatch] { + return pulumix.Output[[]*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRolePatchArrayOutput) Index(i pulumi.IntInput) ClusterRolePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ClusterRolePatch { return vs[0].([]*ClusterRolePatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o ClusterRolePatchMapOutput) ToClusterRolePatchMapOutputWithContext(ctx co return o } +func (o ClusterRolePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ClusterRolePatch] { + return pulumix.Output[map[string]*ClusterRolePatch]{ + OutputState: o.OutputState, + } +} + func (o ClusterRolePatchMapOutput) MapIndex(k pulumi.StringInput) ClusterRolePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ClusterRolePatch { return vs[0].(map[string]*ClusterRolePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/rbac/v1beta1/pulumiTypes.go index d984f7ef44..c2cc855230 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/rbac/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -49,6 +50,12 @@ func (i AggregationRuleArgs) ToAggregationRuleOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AggregationRuleOutput) } +func (i AggregationRuleArgs) ToOutput(ctx context.Context) pulumix.Output[AggregationRule] { + return pulumix.Output[AggregationRule]{ + OutputState: i.ToAggregationRuleOutputWithContext(ctx).OutputState, + } +} + func (i AggregationRuleArgs) ToAggregationRulePtrOutput() AggregationRulePtrOutput { return i.ToAggregationRulePtrOutputWithContext(context.Background()) } @@ -90,6 +97,12 @@ func (i *aggregationRulePtrType) ToAggregationRulePtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePtrOutput) } +func (i *aggregationRulePtrType) ToOutput(ctx context.Context) pulumix.Output[*AggregationRule] { + return pulumix.Output[*AggregationRule]{ + OutputState: i.ToAggregationRulePtrOutputWithContext(ctx).OutputState, + } +} + // AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole type AggregationRuleOutput struct{ *pulumi.OutputState } @@ -115,6 +128,12 @@ func (o AggregationRuleOutput) ToAggregationRulePtrOutputWithContext(ctx context }).(AggregationRulePtrOutput) } +func (o AggregationRuleOutput) ToOutput(ctx context.Context) pulumix.Output[AggregationRule] { + return pulumix.Output[AggregationRule]{ + OutputState: o.OutputState, + } +} + // ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added func (o AggregationRuleOutput) ClusterRoleSelectors() metav1.LabelSelectorArrayOutput { return o.ApplyT(func(v AggregationRule) []metav1.LabelSelector { return v.ClusterRoleSelectors }).(metav1.LabelSelectorArrayOutput) @@ -134,6 +153,12 @@ func (o AggregationRulePtrOutput) ToAggregationRulePtrOutputWithContext(ctx cont return o } +func (o AggregationRulePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AggregationRule] { + return pulumix.Output[*AggregationRule]{ + OutputState: o.OutputState, + } +} + func (o AggregationRulePtrOutput) Elem() AggregationRuleOutput { return o.ApplyT(func(v *AggregationRule) AggregationRule { if v != nil { @@ -189,6 +214,12 @@ func (i AggregationRulePatchArgs) ToAggregationRulePatchOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePatchOutput) } +func (i AggregationRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[AggregationRulePatch] { + return pulumix.Output[AggregationRulePatch]{ + OutputState: i.ToAggregationRulePatchOutputWithContext(ctx).OutputState, + } +} + func (i AggregationRulePatchArgs) ToAggregationRulePatchPtrOutput() AggregationRulePatchPtrOutput { return i.ToAggregationRulePatchPtrOutputWithContext(context.Background()) } @@ -230,6 +261,12 @@ func (i *aggregationRulePatchPtrType) ToAggregationRulePatchPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(AggregationRulePatchPtrOutput) } +func (i *aggregationRulePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AggregationRulePatch] { + return pulumix.Output[*AggregationRulePatch]{ + OutputState: i.ToAggregationRulePatchPtrOutputWithContext(ctx).OutputState, + } +} + // AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole type AggregationRulePatchOutput struct{ *pulumi.OutputState } @@ -255,6 +292,12 @@ func (o AggregationRulePatchOutput) ToAggregationRulePatchPtrOutputWithContext(c }).(AggregationRulePatchPtrOutput) } +func (o AggregationRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[AggregationRulePatch] { + return pulumix.Output[AggregationRulePatch]{ + OutputState: o.OutputState, + } +} + // ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added func (o AggregationRulePatchOutput) ClusterRoleSelectors() metav1.LabelSelectorPatchArrayOutput { return o.ApplyT(func(v AggregationRulePatch) []metav1.LabelSelectorPatch { return v.ClusterRoleSelectors }).(metav1.LabelSelectorPatchArrayOutput) @@ -274,6 +317,12 @@ func (o AggregationRulePatchPtrOutput) ToAggregationRulePatchPtrOutputWithContex return o } +func (o AggregationRulePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AggregationRulePatch] { + return pulumix.Output[*AggregationRulePatch]{ + OutputState: o.OutputState, + } +} + func (o AggregationRulePatchPtrOutput) Elem() AggregationRulePatchOutput { return o.ApplyT(func(v *AggregationRulePatch) AggregationRulePatch { if v != nil { @@ -345,6 +394,12 @@ func (i ClusterRoleTypeArgs) ToClusterRoleTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleTypeOutput) } +func (i ClusterRoleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleType] { + return pulumix.Output[ClusterRoleType]{ + OutputState: i.ToClusterRoleTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleTypeArrayInput is an input type that accepts ClusterRoleTypeArray and ClusterRoleTypeArrayOutput values. // You can construct a concrete instance of `ClusterRoleTypeArrayInput` via: // @@ -370,6 +425,12 @@ func (i ClusterRoleTypeArray) ToClusterRoleTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleTypeArrayOutput) } +func (i ClusterRoleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleType] { + return pulumix.Output[[]ClusterRoleType]{ + OutputState: i.ToClusterRoleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. type ClusterRoleTypeOutput struct{ *pulumi.OutputState } @@ -385,6 +446,12 @@ func (o ClusterRoleTypeOutput) ToClusterRoleTypeOutputWithContext(ctx context.Co return o } +func (o ClusterRoleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleType] { + return pulumix.Output[ClusterRoleType]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRoleTypeOutput) AggregationRule() AggregationRulePtrOutput { return o.ApplyT(func(v ClusterRoleType) *AggregationRule { return v.AggregationRule }).(AggregationRulePtrOutput) @@ -424,6 +491,12 @@ func (o ClusterRoleTypeArrayOutput) ToClusterRoleTypeArrayOutputWithContext(ctx return o } +func (o ClusterRoleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleType] { + return pulumix.Output[[]ClusterRoleType]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleTypeArrayOutput) Index(i pulumi.IntInput) ClusterRoleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterRoleType { return vs[0].([]ClusterRoleType)[vs[1].(int)] @@ -481,6 +554,12 @@ func (i ClusterRoleBindingTypeArgs) ToClusterRoleBindingTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingTypeOutput) } +func (i ClusterRoleBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingType] { + return pulumix.Output[ClusterRoleBindingType]{ + OutputState: i.ToClusterRoleBindingTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingTypeArrayInput is an input type that accepts ClusterRoleBindingTypeArray and ClusterRoleBindingTypeArrayOutput values. // You can construct a concrete instance of `ClusterRoleBindingTypeArrayInput` via: // @@ -506,6 +585,12 @@ func (i ClusterRoleBindingTypeArray) ToClusterRoleBindingTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingTypeArrayOutput) } +func (i ClusterRoleBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleBindingType] { + return pulumix.Output[[]ClusterRoleBindingType]{ + OutputState: i.ToClusterRoleBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. type ClusterRoleBindingTypeOutput struct{ *pulumi.OutputState } @@ -521,6 +606,12 @@ func (o ClusterRoleBindingTypeOutput) ToClusterRoleBindingTypeOutputWithContext( return o } +func (o ClusterRoleBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingType] { + return pulumix.Output[ClusterRoleBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -560,6 +651,12 @@ func (o ClusterRoleBindingTypeArrayOutput) ToClusterRoleBindingTypeArrayOutputWi return o } +func (o ClusterRoleBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ClusterRoleBindingType] { + return pulumix.Output[[]ClusterRoleBindingType]{ + OutputState: o.OutputState, + } +} + func (o ClusterRoleBindingTypeArrayOutput) Index(i pulumi.IntInput) ClusterRoleBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterRoleBindingType { return vs[0].([]ClusterRoleBindingType)[vs[1].(int)] @@ -613,6 +710,12 @@ func (i ClusterRoleBindingListTypeArgs) ToClusterRoleBindingListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingListTypeOutput) } +func (i ClusterRoleBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingListType] { + return pulumix.Output[ClusterRoleBindingListType]{ + OutputState: i.ToClusterRoleBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindingList, and will no longer be served in v1.20. type ClusterRoleBindingListTypeOutput struct{ *pulumi.OutputState } @@ -628,6 +731,12 @@ func (o ClusterRoleBindingListTypeOutput) ToClusterRoleBindingListTypeOutputWith return o } +func (o ClusterRoleBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingListType] { + return pulumix.Output[ClusterRoleBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -699,6 +808,12 @@ func (i ClusterRoleBindingPatchTypeArgs) ToClusterRoleBindingPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleBindingPatchTypeOutput) } +func (i ClusterRoleBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingPatchType] { + return pulumix.Output[ClusterRoleBindingPatchType]{ + OutputState: i.ToClusterRoleBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. type ClusterRoleBindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -714,6 +829,12 @@ func (o ClusterRoleBindingPatchTypeOutput) ToClusterRoleBindingPatchTypeOutputWi return o } +func (o ClusterRoleBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleBindingPatchType] { + return pulumix.Output[ClusterRoleBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -786,6 +907,12 @@ func (i ClusterRoleListTypeArgs) ToClusterRoleListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ClusterRoleListTypeOutput) } +func (i ClusterRoleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleListType] { + return pulumix.Output[ClusterRoleListType]{ + OutputState: i.ToClusterRoleListTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRoleList is a collection of ClusterRoles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoles, and will no longer be served in v1.20. type ClusterRoleListTypeOutput struct{ *pulumi.OutputState } @@ -801,6 +928,12 @@ func (o ClusterRoleListTypeOutput) ToClusterRoleListTypeOutputWithContext(ctx co return o } +func (o ClusterRoleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRoleListType] { + return pulumix.Output[ClusterRoleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ClusterRoleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterRoleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -872,6 +1005,12 @@ func (i ClusterRolePatchTypeArgs) ToClusterRolePatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ClusterRolePatchTypeOutput) } +func (i ClusterRolePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ClusterRolePatchType] { + return pulumix.Output[ClusterRolePatchType]{ + OutputState: i.ToClusterRolePatchTypeOutputWithContext(ctx).OutputState, + } +} + // ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. type ClusterRolePatchTypeOutput struct{ *pulumi.OutputState } @@ -887,6 +1026,12 @@ func (o ClusterRolePatchTypeOutput) ToClusterRolePatchTypeOutputWithContext(ctx return o } +func (o ClusterRolePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ClusterRolePatchType] { + return pulumix.Output[ClusterRolePatchType]{ + OutputState: o.OutputState, + } +} + // AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. func (o ClusterRolePatchTypeOutput) AggregationRule() AggregationRulePatchPtrOutput { return o.ApplyT(func(v ClusterRolePatchType) *AggregationRulePatch { return v.AggregationRule }).(AggregationRulePatchPtrOutput) @@ -963,6 +1108,12 @@ func (i PolicyRuleArgs) ToPolicyRuleOutputWithContext(ctx context.Context) Polic return pulumi.ToOutputWithContext(ctx, i).(PolicyRuleOutput) } +func (i PolicyRuleArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRule] { + return pulumix.Output[PolicyRule]{ + OutputState: i.ToPolicyRuleOutputWithContext(ctx).OutputState, + } +} + // PolicyRuleArrayInput is an input type that accepts PolicyRuleArray and PolicyRuleArrayOutput values. // You can construct a concrete instance of `PolicyRuleArrayInput` via: // @@ -988,6 +1139,12 @@ func (i PolicyRuleArray) ToPolicyRuleArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PolicyRuleArrayOutput) } +func (i PolicyRuleArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRule] { + return pulumix.Output[[]PolicyRule]{ + OutputState: i.ToPolicyRuleArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. type PolicyRuleOutput struct{ *pulumi.OutputState } @@ -1003,6 +1160,12 @@ func (o PolicyRuleOutput) ToPolicyRuleOutputWithContext(ctx context.Context) Pol return o } +func (o PolicyRuleOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRule] { + return pulumix.Output[PolicyRule]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. func (o PolicyRuleOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v PolicyRule) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1042,6 +1205,12 @@ func (o PolicyRuleArrayOutput) ToPolicyRuleArrayOutputWithContext(ctx context.Co return o } +func (o PolicyRuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRule] { + return pulumix.Output[[]PolicyRule]{ + OutputState: o.OutputState, + } +} + func (o PolicyRuleArrayOutput) Index(i pulumi.IntInput) PolicyRuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRule { return vs[0].([]PolicyRule)[vs[1].(int)] @@ -1099,6 +1268,12 @@ func (i PolicyRulePatchArgs) ToPolicyRulePatchOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PolicyRulePatchOutput) } +func (i PolicyRulePatchArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyRulePatch] { + return pulumix.Output[PolicyRulePatch]{ + OutputState: i.ToPolicyRulePatchOutputWithContext(ctx).OutputState, + } +} + // PolicyRulePatchArrayInput is an input type that accepts PolicyRulePatchArray and PolicyRulePatchArrayOutput values. // You can construct a concrete instance of `PolicyRulePatchArrayInput` via: // @@ -1124,6 +1299,12 @@ func (i PolicyRulePatchArray) ToPolicyRulePatchArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PolicyRulePatchArrayOutput) } +func (i PolicyRulePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulePatch] { + return pulumix.Output[[]PolicyRulePatch]{ + OutputState: i.ToPolicyRulePatchArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. type PolicyRulePatchOutput struct{ *pulumi.OutputState } @@ -1139,6 +1320,12 @@ func (o PolicyRulePatchOutput) ToPolicyRulePatchOutputWithContext(ctx context.Co return o } +func (o PolicyRulePatchOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyRulePatch] { + return pulumix.Output[PolicyRulePatch]{ + OutputState: o.OutputState, + } +} + // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. func (o PolicyRulePatchOutput) ApiGroups() pulumi.StringArrayOutput { return o.ApplyT(func(v PolicyRulePatch) []string { return v.ApiGroups }).(pulumi.StringArrayOutput) @@ -1178,6 +1365,12 @@ func (o PolicyRulePatchArrayOutput) ToPolicyRulePatchArrayOutputWithContext(ctx return o } +func (o PolicyRulePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyRulePatch] { + return pulumix.Output[[]PolicyRulePatch]{ + OutputState: o.OutputState, + } +} + func (o PolicyRulePatchArrayOutput) Index(i pulumi.IntInput) PolicyRulePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyRulePatch { return vs[0].([]PolicyRulePatch)[vs[1].(int)] @@ -1231,6 +1424,12 @@ func (i RoleTypeArgs) ToRoleTypeOutputWithContext(ctx context.Context) RoleTypeO return pulumi.ToOutputWithContext(ctx, i).(RoleTypeOutput) } +func (i RoleTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleType] { + return pulumix.Output[RoleType]{ + OutputState: i.ToRoleTypeOutputWithContext(ctx).OutputState, + } +} + // RoleTypeArrayInput is an input type that accepts RoleTypeArray and RoleTypeArrayOutput values. // You can construct a concrete instance of `RoleTypeArrayInput` via: // @@ -1256,6 +1455,12 @@ func (i RoleTypeArray) ToRoleTypeArrayOutputWithContext(ctx context.Context) Rol return pulumi.ToOutputWithContext(ctx, i).(RoleTypeArrayOutput) } +func (i RoleTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RoleType] { + return pulumix.Output[[]RoleType]{ + OutputState: i.ToRoleTypeArrayOutputWithContext(ctx).OutputState, + } +} + // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. type RoleTypeOutput struct{ *pulumi.OutputState } @@ -1271,6 +1476,12 @@ func (o RoleTypeOutput) ToRoleTypeOutputWithContext(ctx context.Context) RoleTyp return o } +func (o RoleTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleType] { + return pulumix.Output[RoleType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1305,6 +1516,12 @@ func (o RoleTypeArrayOutput) ToRoleTypeArrayOutputWithContext(ctx context.Contex return o } +func (o RoleTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RoleType] { + return pulumix.Output[[]RoleType]{ + OutputState: o.OutputState, + } +} + func (o RoleTypeArrayOutput) Index(i pulumi.IntInput) RoleTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RoleType { return vs[0].([]RoleType)[vs[1].(int)] @@ -1362,6 +1579,12 @@ func (i RoleBindingTypeArgs) ToRoleBindingTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingTypeOutput) } +func (i RoleBindingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingType] { + return pulumix.Output[RoleBindingType]{ + OutputState: i.ToRoleBindingTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBindingTypeArrayInput is an input type that accepts RoleBindingTypeArray and RoleBindingTypeArrayOutput values. // You can construct a concrete instance of `RoleBindingTypeArrayInput` via: // @@ -1387,6 +1610,12 @@ func (i RoleBindingTypeArray) ToRoleBindingTypeArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingTypeArrayOutput) } +func (i RoleBindingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]RoleBindingType] { + return pulumix.Output[[]RoleBindingType]{ + OutputState: i.ToRoleBindingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. type RoleBindingTypeOutput struct{ *pulumi.OutputState } @@ -1402,6 +1631,12 @@ func (o RoleBindingTypeOutput) ToRoleBindingTypeOutputWithContext(ctx context.Co return o } +func (o RoleBindingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingType] { + return pulumix.Output[RoleBindingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1441,6 +1676,12 @@ func (o RoleBindingTypeArrayOutput) ToRoleBindingTypeArrayOutputWithContext(ctx return o } +func (o RoleBindingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RoleBindingType] { + return pulumix.Output[[]RoleBindingType]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingTypeArrayOutput) Index(i pulumi.IntInput) RoleBindingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) RoleBindingType { return vs[0].([]RoleBindingType)[vs[1].(int)] @@ -1494,6 +1735,12 @@ func (i RoleBindingListTypeArgs) ToRoleBindingListTypeOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListTypeOutput) } +func (i RoleBindingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingListType] { + return pulumix.Output[RoleBindingListType]{ + OutputState: i.ToRoleBindingListTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBindingList is a collection of RoleBindings Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBindingList, and will no longer be served in v1.20. type RoleBindingListTypeOutput struct{ *pulumi.OutputState } @@ -1509,6 +1756,12 @@ func (o RoleBindingListTypeOutput) ToRoleBindingListTypeOutputWithContext(ctx co return o } +func (o RoleBindingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingListType] { + return pulumix.Output[RoleBindingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1580,6 +1833,12 @@ func (i RoleBindingPatchTypeArgs) ToRoleBindingPatchTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchTypeOutput) } +func (i RoleBindingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleBindingPatchType] { + return pulumix.Output[RoleBindingPatchType]{ + OutputState: i.ToRoleBindingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. type RoleBindingPatchTypeOutput struct{ *pulumi.OutputState } @@ -1595,6 +1854,12 @@ func (o RoleBindingPatchTypeOutput) ToRoleBindingPatchTypeOutputWithContext(ctx return o } +func (o RoleBindingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleBindingPatchType] { + return pulumix.Output[RoleBindingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleBindingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1667,6 +1932,12 @@ func (i RoleListTypeArgs) ToRoleListTypeOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleListTypeOutput) } +func (i RoleListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RoleListType] { + return pulumix.Output[RoleListType]{ + OutputState: i.ToRoleListTypeOutputWithContext(ctx).OutputState, + } +} + // RoleList is a collection of Roles Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleList, and will no longer be served in v1.20. type RoleListTypeOutput struct{ *pulumi.OutputState } @@ -1682,6 +1953,12 @@ func (o RoleListTypeOutput) ToRoleListTypeOutputWithContext(ctx context.Context) return o } +func (o RoleListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RoleListType] { + return pulumix.Output[RoleListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1749,6 +2026,12 @@ func (i RolePatchTypeArgs) ToRolePatchTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(RolePatchTypeOutput) } +func (i RolePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[RolePatchType] { + return pulumix.Output[RolePatchType]{ + OutputState: i.ToRolePatchTypeOutputWithContext(ctx).OutputState, + } +} + // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. type RolePatchTypeOutput struct{ *pulumi.OutputState } @@ -1764,6 +2047,12 @@ func (o RolePatchTypeOutput) ToRolePatchTypeOutputWithContext(ctx context.Contex return o } +func (o RolePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[RolePatchType] { + return pulumix.Output[RolePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RolePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v RolePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1827,6 +2116,12 @@ func (i RoleRefArgs) ToRoleRefOutputWithContext(ctx context.Context) RoleRefOutp return pulumi.ToOutputWithContext(ctx, i).(RoleRefOutput) } +func (i RoleRefArgs) ToOutput(ctx context.Context) pulumix.Output[RoleRef] { + return pulumix.Output[RoleRef]{ + OutputState: i.ToRoleRefOutputWithContext(ctx).OutputState, + } +} + // RoleRef contains information that points to the role being used type RoleRefOutput struct{ *pulumi.OutputState } @@ -1842,6 +2137,12 @@ func (o RoleRefOutput) ToRoleRefOutputWithContext(ctx context.Context) RoleRefOu return o } +func (o RoleRefOutput) ToOutput(ctx context.Context) pulumix.Output[RoleRef] { + return pulumix.Output[RoleRef]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced func (o RoleRefOutput) ApiGroup() pulumi.StringOutput { return o.ApplyT(func(v RoleRef) string { return v.ApiGroup }).(pulumi.StringOutput) @@ -1900,6 +2201,12 @@ func (i RoleRefPatchArgs) ToRoleRefPatchOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleRefPatchOutput) } +func (i RoleRefPatchArgs) ToOutput(ctx context.Context) pulumix.Output[RoleRefPatch] { + return pulumix.Output[RoleRefPatch]{ + OutputState: i.ToRoleRefPatchOutputWithContext(ctx).OutputState, + } +} + func (i RoleRefPatchArgs) ToRoleRefPatchPtrOutput() RoleRefPatchPtrOutput { return i.ToRoleRefPatchPtrOutputWithContext(context.Background()) } @@ -1941,6 +2248,12 @@ func (i *roleRefPatchPtrType) ToRoleRefPatchPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(RoleRefPatchPtrOutput) } +func (i *roleRefPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*RoleRefPatch] { + return pulumix.Output[*RoleRefPatch]{ + OutputState: i.ToRoleRefPatchPtrOutputWithContext(ctx).OutputState, + } +} + // RoleRef contains information that points to the role being used type RoleRefPatchOutput struct{ *pulumi.OutputState } @@ -1966,6 +2279,12 @@ func (o RoleRefPatchOutput) ToRoleRefPatchPtrOutputWithContext(ctx context.Conte }).(RoleRefPatchPtrOutput) } +func (o RoleRefPatchOutput) ToOutput(ctx context.Context) pulumix.Output[RoleRefPatch] { + return pulumix.Output[RoleRefPatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced func (o RoleRefPatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v RoleRefPatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1995,6 +2314,12 @@ func (o RoleRefPatchPtrOutput) ToRoleRefPatchPtrOutputWithContext(ctx context.Co return o } +func (o RoleRefPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleRefPatch] { + return pulumix.Output[*RoleRefPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleRefPatchPtrOutput) Elem() RoleRefPatchOutput { return o.ApplyT(func(v *RoleRefPatch) RoleRefPatch { if v != nil { @@ -2082,6 +2407,12 @@ func (i SubjectArgs) ToSubjectOutputWithContext(ctx context.Context) SubjectOutp return pulumi.ToOutputWithContext(ctx, i).(SubjectOutput) } +func (i SubjectArgs) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: i.ToSubjectOutputWithContext(ctx).OutputState, + } +} + // SubjectArrayInput is an input type that accepts SubjectArray and SubjectArrayOutput values. // You can construct a concrete instance of `SubjectArrayInput` via: // @@ -2107,6 +2438,12 @@ func (i SubjectArray) ToSubjectArrayOutputWithContext(ctx context.Context) Subje return pulumi.ToOutputWithContext(ctx, i).(SubjectArrayOutput) } +func (i SubjectArray) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: i.ToSubjectArrayOutputWithContext(ctx).OutputState, + } +} + // Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. type SubjectOutput struct{ *pulumi.OutputState } @@ -2122,6 +2459,12 @@ func (o SubjectOutput) ToSubjectOutputWithContext(ctx context.Context) SubjectOu return o } +func (o SubjectOutput) ToOutput(ctx context.Context) pulumix.Output[Subject] { + return pulumix.Output[Subject]{ + OutputState: o.OutputState, + } +} + // APIGroup holds the API group of the referenced subject. Defaults to "" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io" for User and Group subjects. func (o SubjectOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v Subject) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -2156,6 +2499,12 @@ func (o SubjectArrayOutput) ToSubjectArrayOutputWithContext(ctx context.Context) return o } +func (o SubjectArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]Subject] { + return pulumix.Output[[]Subject]{ + OutputState: o.OutputState, + } +} + func (o SubjectArrayOutput) Index(i pulumi.IntInput) SubjectOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) Subject { return vs[0].([]Subject)[vs[1].(int)] @@ -2209,6 +2558,12 @@ func (i SubjectPatchArgs) ToSubjectPatchOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchOutput) } +func (i SubjectPatchArgs) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: i.ToSubjectPatchOutputWithContext(ctx).OutputState, + } +} + // SubjectPatchArrayInput is an input type that accepts SubjectPatchArray and SubjectPatchArrayOutput values. // You can construct a concrete instance of `SubjectPatchArrayInput` via: // @@ -2234,6 +2589,12 @@ func (i SubjectPatchArray) ToSubjectPatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(SubjectPatchArrayOutput) } +func (i SubjectPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: i.ToSubjectPatchArrayOutputWithContext(ctx).OutputState, + } +} + // Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. type SubjectPatchOutput struct{ *pulumi.OutputState } @@ -2249,6 +2610,12 @@ func (o SubjectPatchOutput) ToSubjectPatchOutputWithContext(ctx context.Context) return o } +func (o SubjectPatchOutput) ToOutput(ctx context.Context) pulumix.Output[SubjectPatch] { + return pulumix.Output[SubjectPatch]{ + OutputState: o.OutputState, + } +} + // APIGroup holds the API group of the referenced subject. Defaults to "" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io" for User and Group subjects. func (o SubjectPatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v SubjectPatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -2283,6 +2650,12 @@ func (o SubjectPatchArrayOutput) ToSubjectPatchArrayOutputWithContext(ctx contex return o } +func (o SubjectPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]SubjectPatch] { + return pulumix.Output[[]SubjectPatch]{ + OutputState: o.OutputState, + } +} + func (o SubjectPatchArrayOutput) Index(i pulumi.IntInput) SubjectPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) SubjectPatch { return vs[0].([]SubjectPatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/role.go b/sdk/go/kubernetes/rbac/v1beta1/role.go index 43185c05b7..b238a22905 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/role.go +++ b/sdk/go/kubernetes/rbac/v1beta1/role.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. @@ -122,6 +123,12 @@ func (i *Role) ToRoleOutputWithContext(ctx context.Context) RoleOutput { return pulumi.ToOutputWithContext(ctx, i).(RoleOutput) } +func (i *Role) ToOutput(ctx context.Context) pulumix.Output[*Role] { + return pulumix.Output[*Role]{ + OutputState: i.ToRoleOutputWithContext(ctx).OutputState, + } +} + // RoleArrayInput is an input type that accepts RoleArray and RoleArrayOutput values. // You can construct a concrete instance of `RoleArrayInput` via: // @@ -147,6 +154,12 @@ func (i RoleArray) ToRoleArrayOutputWithContext(ctx context.Context) RoleArrayOu return pulumi.ToOutputWithContext(ctx, i).(RoleArrayOutput) } +func (i RoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*Role] { + return pulumix.Output[[]*Role]{ + OutputState: i.ToRoleArrayOutputWithContext(ctx).OutputState, + } +} + // RoleMapInput is an input type that accepts RoleMap and RoleMapOutput values. // You can construct a concrete instance of `RoleMapInput` via: // @@ -172,6 +185,12 @@ func (i RoleMap) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOutput { return pulumi.ToOutputWithContext(ctx, i).(RoleMapOutput) } +func (i RoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Role] { + return pulumix.Output[map[string]*Role]{ + OutputState: i.ToRoleMapOutputWithContext(ctx).OutputState, + } +} + type RoleOutput struct{ *pulumi.OutputState } func (RoleOutput) ElementType() reflect.Type { @@ -186,6 +205,12 @@ func (o RoleOutput) ToRoleOutputWithContext(ctx context.Context) RoleOutput { return o } +func (o RoleOutput) ToOutput(ctx context.Context) pulumix.Output[*Role] { + return pulumix.Output[*Role]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *Role) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -220,6 +245,12 @@ func (o RoleArrayOutput) ToRoleArrayOutputWithContext(ctx context.Context) RoleA return o } +func (o RoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Role] { + return pulumix.Output[[]*Role]{ + OutputState: o.OutputState, + } +} + func (o RoleArrayOutput) Index(i pulumi.IntInput) RoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Role { return vs[0].([]*Role)[vs[1].(int)] @@ -240,6 +271,12 @@ func (o RoleMapOutput) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOu return o } +func (o RoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Role] { + return pulumix.Output[map[string]*Role]{ + OutputState: o.OutputState, + } +} + func (o RoleMapOutput) MapIndex(k pulumi.StringInput) RoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Role { return vs[0].(map[string]*Role)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/roleBinding.go b/sdk/go/kubernetes/rbac/v1beta1/roleBinding.go index e279d5f6ed..ee9556aecf 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/roleBinding.go +++ b/sdk/go/kubernetes/rbac/v1beta1/roleBinding.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. @@ -132,6 +133,12 @@ func (i *RoleBinding) ToRoleBindingOutputWithContext(ctx context.Context) RoleBi return pulumi.ToOutputWithContext(ctx, i).(RoleBindingOutput) } +func (i *RoleBinding) ToOutput(ctx context.Context) pulumix.Output[*RoleBinding] { + return pulumix.Output[*RoleBinding]{ + OutputState: i.ToRoleBindingOutputWithContext(ctx).OutputState, + } +} + // RoleBindingArrayInput is an input type that accepts RoleBindingArray and RoleBindingArrayOutput values. // You can construct a concrete instance of `RoleBindingArrayInput` via: // @@ -157,6 +164,12 @@ func (i RoleBindingArray) ToRoleBindingArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingArrayOutput) } +func (i RoleBindingArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBinding] { + return pulumix.Output[[]*RoleBinding]{ + OutputState: i.ToRoleBindingArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingMapInput is an input type that accepts RoleBindingMap and RoleBindingMapOutput values. // You can construct a concrete instance of `RoleBindingMapInput` via: // @@ -182,6 +195,12 @@ func (i RoleBindingMap) ToRoleBindingMapOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RoleBindingMapOutput) } +func (i RoleBindingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBinding] { + return pulumix.Output[map[string]*RoleBinding]{ + OutputState: i.ToRoleBindingMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingOutput struct{ *pulumi.OutputState } func (RoleBindingOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o RoleBindingOutput) ToRoleBindingOutputWithContext(ctx context.Context) R return o } +func (o RoleBindingOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBinding] { + return pulumix.Output[*RoleBinding]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleBinding) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -235,6 +260,12 @@ func (o RoleBindingArrayOutput) ToRoleBindingArrayOutputWithContext(ctx context. return o } +func (o RoleBindingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBinding] { + return pulumix.Output[[]*RoleBinding]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingArrayOutput) Index(i pulumi.IntInput) RoleBindingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBinding { return vs[0].([]*RoleBinding)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o RoleBindingMapOutput) ToRoleBindingMapOutputWithContext(ctx context.Cont return o } +func (o RoleBindingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBinding] { + return pulumix.Output[map[string]*RoleBinding]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingMapOutput) MapIndex(k pulumi.StringInput) RoleBindingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBinding { return vs[0].(map[string]*RoleBinding)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/roleBindingList.go b/sdk/go/kubernetes/rbac/v1beta1/roleBindingList.go index cf18303b27..13833835b5 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/roleBindingList.go +++ b/sdk/go/kubernetes/rbac/v1beta1/roleBindingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleBindingList is a collection of RoleBindings Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBindingList, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *RoleBindingList) ToRoleBindingListOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListOutput) } +func (i *RoleBindingList) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingList] { + return pulumix.Output[*RoleBindingList]{ + OutputState: i.ToRoleBindingListOutputWithContext(ctx).OutputState, + } +} + // RoleBindingListArrayInput is an input type that accepts RoleBindingListArray and RoleBindingListArrayOutput values. // You can construct a concrete instance of `RoleBindingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RoleBindingListArray) ToRoleBindingListArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListArrayOutput) } +func (i RoleBindingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingList] { + return pulumix.Output[[]*RoleBindingList]{ + OutputState: i.ToRoleBindingListArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingListMapInput is an input type that accepts RoleBindingListMap and RoleBindingListMapOutput values. // You can construct a concrete instance of `RoleBindingListMapInput` via: // @@ -167,6 +180,12 @@ func (i RoleBindingListMap) ToRoleBindingListMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(RoleBindingListMapOutput) } +func (i RoleBindingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingList] { + return pulumix.Output[map[string]*RoleBindingList]{ + OutputState: i.ToRoleBindingListMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingListOutput struct{ *pulumi.OutputState } func (RoleBindingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RoleBindingListOutput) ToRoleBindingListOutputWithContext(ctx context.Co return o } +func (o RoleBindingListOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingList] { + return pulumix.Output[*RoleBindingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleBindingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RoleBindingListArrayOutput) ToRoleBindingListArrayOutputWithContext(ctx return o } +func (o RoleBindingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingList] { + return pulumix.Output[[]*RoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingListArrayOutput) Index(i pulumi.IntInput) RoleBindingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBindingList { return vs[0].([]*RoleBindingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RoleBindingListMapOutput) ToRoleBindingListMapOutputWithContext(ctx cont return o } +func (o RoleBindingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingList] { + return pulumix.Output[map[string]*RoleBindingList]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingListMapOutput) MapIndex(k pulumi.StringInput) RoleBindingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBindingList { return vs[0].(map[string]*RoleBindingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/roleBindingPatch.go b/sdk/go/kubernetes/rbac/v1beta1/roleBindingPatch.go index c0c15aaf7c..996a214136 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/roleBindingPatch.go +++ b/sdk/go/kubernetes/rbac/v1beta1/roleBindingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -134,6 +135,12 @@ func (i *RoleBindingPatch) ToRoleBindingPatchOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchOutput) } +func (i *RoleBindingPatch) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingPatch] { + return pulumix.Output[*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchOutputWithContext(ctx).OutputState, + } +} + // RoleBindingPatchArrayInput is an input type that accepts RoleBindingPatchArray and RoleBindingPatchArrayOutput values. // You can construct a concrete instance of `RoleBindingPatchArrayInput` via: // @@ -159,6 +166,12 @@ func (i RoleBindingPatchArray) ToRoleBindingPatchArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchArrayOutput) } +func (i RoleBindingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingPatch] { + return pulumix.Output[[]*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // RoleBindingPatchMapInput is an input type that accepts RoleBindingPatchMap and RoleBindingPatchMapOutput values. // You can construct a concrete instance of `RoleBindingPatchMapInput` via: // @@ -184,6 +197,12 @@ func (i RoleBindingPatchMap) ToRoleBindingPatchMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(RoleBindingPatchMapOutput) } +func (i RoleBindingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingPatch] { + return pulumix.Output[map[string]*RoleBindingPatch]{ + OutputState: i.ToRoleBindingPatchMapOutputWithContext(ctx).OutputState, + } +} + type RoleBindingPatchOutput struct{ *pulumi.OutputState } func (RoleBindingPatchOutput) ElementType() reflect.Type { @@ -198,6 +217,12 @@ func (o RoleBindingPatchOutput) ToRoleBindingPatchOutputWithContext(ctx context. return o } +func (o RoleBindingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleBindingPatch] { + return pulumix.Output[*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleBindingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RoleBindingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -237,6 +262,12 @@ func (o RoleBindingPatchArrayOutput) ToRoleBindingPatchArrayOutputWithContext(ct return o } +func (o RoleBindingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleBindingPatch] { + return pulumix.Output[[]*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingPatchArrayOutput) Index(i pulumi.IntInput) RoleBindingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleBindingPatch { return vs[0].([]*RoleBindingPatch)[vs[1].(int)] @@ -257,6 +288,12 @@ func (o RoleBindingPatchMapOutput) ToRoleBindingPatchMapOutputWithContext(ctx co return o } +func (o RoleBindingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleBindingPatch] { + return pulumix.Output[map[string]*RoleBindingPatch]{ + OutputState: o.OutputState, + } +} + func (o RoleBindingPatchMapOutput) MapIndex(k pulumi.StringInput) RoleBindingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleBindingPatch { return vs[0].(map[string]*RoleBindingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/roleList.go b/sdk/go/kubernetes/rbac/v1beta1/roleList.go index 19a17ca54d..bc0f20c6b2 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/roleList.go +++ b/sdk/go/kubernetes/rbac/v1beta1/roleList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // RoleList is a collection of Roles Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleList, and will no longer be served in v1.20. @@ -117,6 +118,12 @@ func (i *RoleList) ToRoleListOutputWithContext(ctx context.Context) RoleListOutp return pulumi.ToOutputWithContext(ctx, i).(RoleListOutput) } +func (i *RoleList) ToOutput(ctx context.Context) pulumix.Output[*RoleList] { + return pulumix.Output[*RoleList]{ + OutputState: i.ToRoleListOutputWithContext(ctx).OutputState, + } +} + // RoleListArrayInput is an input type that accepts RoleListArray and RoleListArrayOutput values. // You can construct a concrete instance of `RoleListArrayInput` via: // @@ -142,6 +149,12 @@ func (i RoleListArray) ToRoleListArrayOutputWithContext(ctx context.Context) Rol return pulumi.ToOutputWithContext(ctx, i).(RoleListArrayOutput) } +func (i RoleListArray) ToOutput(ctx context.Context) pulumix.Output[[]*RoleList] { + return pulumix.Output[[]*RoleList]{ + OutputState: i.ToRoleListArrayOutputWithContext(ctx).OutputState, + } +} + // RoleListMapInput is an input type that accepts RoleListMap and RoleListMapOutput values. // You can construct a concrete instance of `RoleListMapInput` via: // @@ -167,6 +180,12 @@ func (i RoleListMap) ToRoleListMapOutputWithContext(ctx context.Context) RoleLis return pulumi.ToOutputWithContext(ctx, i).(RoleListMapOutput) } +func (i RoleListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleList] { + return pulumix.Output[map[string]*RoleList]{ + OutputState: i.ToRoleListMapOutputWithContext(ctx).OutputState, + } +} + type RoleListOutput struct{ *pulumi.OutputState } func (RoleListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o RoleListOutput) ToRoleListOutputWithContext(ctx context.Context) RoleLis return o } +func (o RoleListOutput) ToOutput(ctx context.Context) pulumix.Output[*RoleList] { + return pulumix.Output[*RoleList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RoleListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *RoleList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o RoleListArrayOutput) ToRoleListArrayOutputWithContext(ctx context.Contex return o } +func (o RoleListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RoleList] { + return pulumix.Output[[]*RoleList]{ + OutputState: o.OutputState, + } +} + func (o RoleListArrayOutput) Index(i pulumi.IntInput) RoleListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RoleList { return vs[0].([]*RoleList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o RoleListMapOutput) ToRoleListMapOutputWithContext(ctx context.Context) R return o } +func (o RoleListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RoleList] { + return pulumix.Output[map[string]*RoleList]{ + OutputState: o.OutputState, + } +} + func (o RoleListMapOutput) MapIndex(k pulumi.StringInput) RoleListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RoleList { return vs[0].(map[string]*RoleList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/rbac/v1beta1/rolePatch.go b/sdk/go/kubernetes/rbac/v1beta1/rolePatch.go index 876d4bd179..1cb9b217d6 100644 --- a/sdk/go/kubernetes/rbac/v1beta1/rolePatch.go +++ b/sdk/go/kubernetes/rbac/v1beta1/rolePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -128,6 +129,12 @@ func (i *RolePatch) ToRolePatchOutputWithContext(ctx context.Context) RolePatchO return pulumi.ToOutputWithContext(ctx, i).(RolePatchOutput) } +func (i *RolePatch) ToOutput(ctx context.Context) pulumix.Output[*RolePatch] { + return pulumix.Output[*RolePatch]{ + OutputState: i.ToRolePatchOutputWithContext(ctx).OutputState, + } +} + // RolePatchArrayInput is an input type that accepts RolePatchArray and RolePatchArrayOutput values. // You can construct a concrete instance of `RolePatchArrayInput` via: // @@ -153,6 +160,12 @@ func (i RolePatchArray) ToRolePatchArrayOutputWithContext(ctx context.Context) R return pulumi.ToOutputWithContext(ctx, i).(RolePatchArrayOutput) } +func (i RolePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*RolePatch] { + return pulumix.Output[[]*RolePatch]{ + OutputState: i.ToRolePatchArrayOutputWithContext(ctx).OutputState, + } +} + // RolePatchMapInput is an input type that accepts RolePatchMap and RolePatchMapOutput values. // You can construct a concrete instance of `RolePatchMapInput` via: // @@ -178,6 +191,12 @@ func (i RolePatchMap) ToRolePatchMapOutputWithContext(ctx context.Context) RoleP return pulumi.ToOutputWithContext(ctx, i).(RolePatchMapOutput) } +func (i RolePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RolePatch] { + return pulumix.Output[map[string]*RolePatch]{ + OutputState: i.ToRolePatchMapOutputWithContext(ctx).OutputState, + } +} + type RolePatchOutput struct{ *pulumi.OutputState } func (RolePatchOutput) ElementType() reflect.Type { @@ -192,6 +211,12 @@ func (o RolePatchOutput) ToRolePatchOutputWithContext(ctx context.Context) RoleP return o } +func (o RolePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*RolePatch] { + return pulumix.Output[*RolePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o RolePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *RolePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o RolePatchArrayOutput) ToRolePatchArrayOutputWithContext(ctx context.Cont return o } +func (o RolePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RolePatch] { + return pulumix.Output[[]*RolePatch]{ + OutputState: o.OutputState, + } +} + func (o RolePatchArrayOutput) Index(i pulumi.IntInput) RolePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RolePatch { return vs[0].([]*RolePatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o RolePatchMapOutput) ToRolePatchMapOutputWithContext(ctx context.Context) return o } +func (o RolePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RolePatch] { + return pulumix.Output[map[string]*RolePatch]{ + OutputState: o.OutputState, + } +} + func (o RolePatchMapOutput) MapIndex(k pulumi.StringInput) RolePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RolePatch { return vs[0].(map[string]*RolePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/podScheduling.go b/sdk/go/kubernetes/resource/v1alpha1/podScheduling.go index 5a56535183..6eaf29034a 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/podScheduling.go +++ b/sdk/go/kubernetes/resource/v1alpha1/podScheduling.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodScheduling objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode. @@ -121,6 +122,12 @@ func (i *PodScheduling) ToPodSchedulingOutputWithContext(ctx context.Context) Po return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingOutput) } +func (i *PodScheduling) ToOutput(ctx context.Context) pulumix.Output[*PodScheduling] { + return pulumix.Output[*PodScheduling]{ + OutputState: i.ToPodSchedulingOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingArrayInput is an input type that accepts PodSchedulingArray and PodSchedulingArrayOutput values. // You can construct a concrete instance of `PodSchedulingArrayInput` via: // @@ -146,6 +153,12 @@ func (i PodSchedulingArray) ToPodSchedulingArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingArrayOutput) } +func (i PodSchedulingArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodScheduling] { + return pulumix.Output[[]*PodScheduling]{ + OutputState: i.ToPodSchedulingArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingMapInput is an input type that accepts PodSchedulingMap and PodSchedulingMapOutput values. // You can construct a concrete instance of `PodSchedulingMapInput` via: // @@ -171,6 +184,12 @@ func (i PodSchedulingMap) ToPodSchedulingMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingMapOutput) } +func (i PodSchedulingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodScheduling] { + return pulumix.Output[map[string]*PodScheduling]{ + OutputState: i.ToPodSchedulingMapOutputWithContext(ctx).OutputState, + } +} + type PodSchedulingOutput struct{ *pulumi.OutputState } func (PodSchedulingOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o PodSchedulingOutput) ToPodSchedulingOutputWithContext(ctx context.Contex return o } +func (o PodSchedulingOutput) ToOutput(ctx context.Context) pulumix.Output[*PodScheduling] { + return pulumix.Output[*PodScheduling]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodScheduling) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o PodSchedulingArrayOutput) ToPodSchedulingArrayOutputWithContext(ctx cont return o } +func (o PodSchedulingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodScheduling] { + return pulumix.Output[[]*PodScheduling]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingArrayOutput) Index(i pulumi.IntInput) PodSchedulingOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodScheduling { return vs[0].([]*PodScheduling)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o PodSchedulingMapOutput) ToPodSchedulingMapOutputWithContext(ctx context. return o } +func (o PodSchedulingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodScheduling] { + return pulumix.Output[map[string]*PodScheduling]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingMapOutput) MapIndex(k pulumi.StringInput) PodSchedulingOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodScheduling { return vs[0].(map[string]*PodScheduling)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/podSchedulingList.go b/sdk/go/kubernetes/resource/v1alpha1/podSchedulingList.go index 9b358f215d..df2e938a1f 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/podSchedulingList.go +++ b/sdk/go/kubernetes/resource/v1alpha1/podSchedulingList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSchedulingList is a collection of Pod scheduling objects. @@ -117,6 +118,12 @@ func (i *PodSchedulingList) ToPodSchedulingListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingListOutput) } +func (i *PodSchedulingList) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingList] { + return pulumix.Output[*PodSchedulingList]{ + OutputState: i.ToPodSchedulingListOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingListArrayInput is an input type that accepts PodSchedulingListArray and PodSchedulingListArrayOutput values. // You can construct a concrete instance of `PodSchedulingListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodSchedulingListArray) ToPodSchedulingListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingListArrayOutput) } +func (i PodSchedulingListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingList] { + return pulumix.Output[[]*PodSchedulingList]{ + OutputState: i.ToPodSchedulingListArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingListMapInput is an input type that accepts PodSchedulingListMap and PodSchedulingListMapOutput values. // You can construct a concrete instance of `PodSchedulingListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodSchedulingListMap) ToPodSchedulingListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingListMapOutput) } +func (i PodSchedulingListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingList] { + return pulumix.Output[map[string]*PodSchedulingList]{ + OutputState: i.ToPodSchedulingListMapOutputWithContext(ctx).OutputState, + } +} + type PodSchedulingListOutput struct{ *pulumi.OutputState } func (PodSchedulingListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodSchedulingListOutput) ToPodSchedulingListOutputWithContext(ctx contex return o } +func (o PodSchedulingListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingList] { + return pulumix.Output[*PodSchedulingList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSchedulingList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodSchedulingListArrayOutput) ToPodSchedulingListArrayOutputWithContext( return o } +func (o PodSchedulingListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingList] { + return pulumix.Output[[]*PodSchedulingList]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingListArrayOutput) Index(i pulumi.IntInput) PodSchedulingListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSchedulingList { return vs[0].([]*PodSchedulingList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodSchedulingListMapOutput) ToPodSchedulingListMapOutputWithContext(ctx return o } +func (o PodSchedulingListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingList] { + return pulumix.Output[map[string]*PodSchedulingList]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingListMapOutput) MapIndex(k pulumi.StringInput) PodSchedulingListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSchedulingList { return vs[0].(map[string]*PodSchedulingList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/podSchedulingPatch.go b/sdk/go/kubernetes/resource/v1alpha1/podSchedulingPatch.go index a914a0bfb6..8007947488 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/podSchedulingPatch.go +++ b/sdk/go/kubernetes/resource/v1alpha1/podSchedulingPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -123,6 +124,12 @@ func (i *PodSchedulingPatch) ToPodSchedulingPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingPatchOutput) } +func (i *PodSchedulingPatch) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingPatch] { + return pulumix.Output[*PodSchedulingPatch]{ + OutputState: i.ToPodSchedulingPatchOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingPatchArrayInput is an input type that accepts PodSchedulingPatchArray and PodSchedulingPatchArrayOutput values. // You can construct a concrete instance of `PodSchedulingPatchArrayInput` via: // @@ -148,6 +155,12 @@ func (i PodSchedulingPatchArray) ToPodSchedulingPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingPatchArrayOutput) } +func (i PodSchedulingPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingPatch] { + return pulumix.Output[[]*PodSchedulingPatch]{ + OutputState: i.ToPodSchedulingPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingPatchMapInput is an input type that accepts PodSchedulingPatchMap and PodSchedulingPatchMapOutput values. // You can construct a concrete instance of `PodSchedulingPatchMapInput` via: // @@ -173,6 +186,12 @@ func (i PodSchedulingPatchMap) ToPodSchedulingPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingPatchMapOutput) } +func (i PodSchedulingPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingPatch] { + return pulumix.Output[map[string]*PodSchedulingPatch]{ + OutputState: i.ToPodSchedulingPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodSchedulingPatchOutput struct{ *pulumi.OutputState } func (PodSchedulingPatchOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o PodSchedulingPatchOutput) ToPodSchedulingPatchOutputWithContext(ctx cont return o } +func (o PodSchedulingPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingPatch] { + return pulumix.Output[*PodSchedulingPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodSchedulingPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o PodSchedulingPatchArrayOutput) ToPodSchedulingPatchArrayOutputWithContex return o } +func (o PodSchedulingPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingPatch] { + return pulumix.Output[[]*PodSchedulingPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingPatchArrayOutput) Index(i pulumi.IntInput) PodSchedulingPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSchedulingPatch { return vs[0].([]*PodSchedulingPatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o PodSchedulingPatchMapOutput) ToPodSchedulingPatchMapOutputWithContext(ct return o } +func (o PodSchedulingPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingPatch] { + return pulumix.Output[map[string]*PodSchedulingPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingPatchMapOutput) MapIndex(k pulumi.StringInput) PodSchedulingPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSchedulingPatch { return vs[0].(map[string]*PodSchedulingPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/resource/v1alpha1/pulumiTypes.go index 337dc0e3b4..47813e8cfd 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/resource/v1alpha1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -66,6 +67,12 @@ func (i AllocationResultArgs) ToAllocationResultOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(AllocationResultOutput) } +func (i AllocationResultArgs) ToOutput(ctx context.Context) pulumix.Output[AllocationResult] { + return pulumix.Output[AllocationResult]{ + OutputState: i.ToAllocationResultOutputWithContext(ctx).OutputState, + } +} + func (i AllocationResultArgs) ToAllocationResultPtrOutput() AllocationResultPtrOutput { return i.ToAllocationResultPtrOutputWithContext(context.Background()) } @@ -107,6 +114,12 @@ func (i *allocationResultPtrType) ToAllocationResultPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(AllocationResultPtrOutput) } +func (i *allocationResultPtrType) ToOutput(ctx context.Context) pulumix.Output[*AllocationResult] { + return pulumix.Output[*AllocationResult]{ + OutputState: i.ToAllocationResultPtrOutputWithContext(ctx).OutputState, + } +} + // AllocationResult contains attributed of an allocated resource. type AllocationResultOutput struct{ *pulumi.OutputState } @@ -132,6 +145,12 @@ func (o AllocationResultOutput) ToAllocationResultPtrOutputWithContext(ctx conte }).(AllocationResultPtrOutput) } +func (o AllocationResultOutput) ToOutput(ctx context.Context) pulumix.Output[AllocationResult] { + return pulumix.Output[AllocationResult]{ + OutputState: o.OutputState, + } +} + // This field will get set by the resource driver after it has allocated the resource driver to inform the scheduler where it can schedule Pods using the ResourceClaim. // // Setting this field is optional. If null, the resource is available everywhere. @@ -165,6 +184,12 @@ func (o AllocationResultPtrOutput) ToAllocationResultPtrOutputWithContext(ctx co return o } +func (o AllocationResultPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AllocationResult] { + return pulumix.Output[*AllocationResult]{ + OutputState: o.OutputState, + } +} + func (o AllocationResultPtrOutput) Elem() AllocationResultOutput { return o.ApplyT(func(v *AllocationResult) AllocationResult { if v != nil { @@ -260,6 +285,12 @@ func (i AllocationResultPatchArgs) ToAllocationResultPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AllocationResultPatchOutput) } +func (i AllocationResultPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllocationResultPatch] { + return pulumix.Output[AllocationResultPatch]{ + OutputState: i.ToAllocationResultPatchOutputWithContext(ctx).OutputState, + } +} + func (i AllocationResultPatchArgs) ToAllocationResultPatchPtrOutput() AllocationResultPatchPtrOutput { return i.ToAllocationResultPatchPtrOutputWithContext(context.Background()) } @@ -301,6 +332,12 @@ func (i *allocationResultPatchPtrType) ToAllocationResultPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(AllocationResultPatchPtrOutput) } +func (i *allocationResultPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AllocationResultPatch] { + return pulumix.Output[*AllocationResultPatch]{ + OutputState: i.ToAllocationResultPatchPtrOutputWithContext(ctx).OutputState, + } +} + // AllocationResult contains attributed of an allocated resource. type AllocationResultPatchOutput struct{ *pulumi.OutputState } @@ -326,6 +363,12 @@ func (o AllocationResultPatchOutput) ToAllocationResultPatchPtrOutputWithContext }).(AllocationResultPatchPtrOutput) } +func (o AllocationResultPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllocationResultPatch] { + return pulumix.Output[AllocationResultPatch]{ + OutputState: o.OutputState, + } +} + // This field will get set by the resource driver after it has allocated the resource driver to inform the scheduler where it can schedule Pods using the ResourceClaim. // // Setting this field is optional. If null, the resource is available everywhere. @@ -359,6 +402,12 @@ func (o AllocationResultPatchPtrOutput) ToAllocationResultPatchPtrOutputWithCont return o } +func (o AllocationResultPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AllocationResultPatch] { + return pulumix.Output[*AllocationResultPatch]{ + OutputState: o.OutputState, + } +} + func (o AllocationResultPatchPtrOutput) Elem() AllocationResultPatchOutput { return o.ApplyT(func(v *AllocationResultPatch) AllocationResultPatch { if v != nil { @@ -458,6 +507,12 @@ func (i PodSchedulingTypeArgs) ToPodSchedulingTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingTypeOutput) } +func (i PodSchedulingTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingType] { + return pulumix.Output[PodSchedulingType]{ + OutputState: i.ToPodSchedulingTypeOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingTypeArrayInput is an input type that accepts PodSchedulingTypeArray and PodSchedulingTypeArrayOutput values. // You can construct a concrete instance of `PodSchedulingTypeArrayInput` via: // @@ -483,6 +538,12 @@ func (i PodSchedulingTypeArray) ToPodSchedulingTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingTypeArrayOutput) } +func (i PodSchedulingTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingType] { + return pulumix.Output[[]PodSchedulingType]{ + OutputState: i.ToPodSchedulingTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodScheduling objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -500,6 +561,12 @@ func (o PodSchedulingTypeOutput) ToPodSchedulingTypeOutputWithContext(ctx contex return o } +func (o PodSchedulingTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingType] { + return pulumix.Output[PodSchedulingType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -539,6 +606,12 @@ func (o PodSchedulingTypeArrayOutput) ToPodSchedulingTypeArrayOutputWithContext( return o } +func (o PodSchedulingTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingType] { + return pulumix.Output[[]PodSchedulingType]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingTypeArrayOutput) Index(i pulumi.IntInput) PodSchedulingTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodSchedulingType { return vs[0].([]PodSchedulingType)[vs[1].(int)] @@ -592,6 +665,12 @@ func (i PodSchedulingListTypeArgs) ToPodSchedulingListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingListTypeOutput) } +func (i PodSchedulingListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingListType] { + return pulumix.Output[PodSchedulingListType]{ + OutputState: i.ToPodSchedulingListTypeOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingList is a collection of Pod scheduling objects. type PodSchedulingListTypeOutput struct{ *pulumi.OutputState } @@ -607,6 +686,12 @@ func (o PodSchedulingListTypeOutput) ToPodSchedulingListTypeOutputWithContext(ct return o } +func (o PodSchedulingListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingListType] { + return pulumix.Output[PodSchedulingListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -682,6 +767,12 @@ func (i PodSchedulingPatchTypeArgs) ToPodSchedulingPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingPatchTypeOutput) } +func (i PodSchedulingPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingPatchType] { + return pulumix.Output[PodSchedulingPatchType]{ + OutputState: i.ToPodSchedulingPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodScheduling objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -699,6 +790,12 @@ func (o PodSchedulingPatchTypeOutput) ToPodSchedulingPatchTypeOutputWithContext( return o } +func (o PodSchedulingPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingPatchType] { + return pulumix.Output[PodSchedulingPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -767,6 +864,12 @@ func (i PodSchedulingSpecArgs) ToPodSchedulingSpecOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingSpecOutput) } +func (i PodSchedulingSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingSpec] { + return pulumix.Output[PodSchedulingSpec]{ + OutputState: i.ToPodSchedulingSpecOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingSpec describes where resources for the Pod are needed. type PodSchedulingSpecOutput struct{ *pulumi.OutputState } @@ -782,6 +885,12 @@ func (o PodSchedulingSpecOutput) ToPodSchedulingSpecOutputWithContext(ctx contex return o } +func (o PodSchedulingSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingSpec] { + return pulumix.Output[PodSchedulingSpec]{ + OutputState: o.OutputState, + } +} + // PotentialNodes lists nodes where the Pod might be able to run. // // The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced. @@ -837,6 +946,12 @@ func (i PodSchedulingSpecPatchArgs) ToPodSchedulingSpecPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingSpecPatchOutput) } +func (i PodSchedulingSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingSpecPatch] { + return pulumix.Output[PodSchedulingSpecPatch]{ + OutputState: i.ToPodSchedulingSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSchedulingSpecPatchArgs) ToPodSchedulingSpecPatchPtrOutput() PodSchedulingSpecPatchPtrOutput { return i.ToPodSchedulingSpecPatchPtrOutputWithContext(context.Background()) } @@ -878,6 +993,12 @@ func (i *podSchedulingSpecPatchPtrType) ToPodSchedulingSpecPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingSpecPatchPtrOutput) } +func (i *podSchedulingSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingSpecPatch] { + return pulumix.Output[*PodSchedulingSpecPatch]{ + OutputState: i.ToPodSchedulingSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingSpec describes where resources for the Pod are needed. type PodSchedulingSpecPatchOutput struct{ *pulumi.OutputState } @@ -903,6 +1024,12 @@ func (o PodSchedulingSpecPatchOutput) ToPodSchedulingSpecPatchPtrOutputWithConte }).(PodSchedulingSpecPatchPtrOutput) } +func (o PodSchedulingSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingSpecPatch] { + return pulumix.Output[PodSchedulingSpecPatch]{ + OutputState: o.OutputState, + } +} + // PotentialNodes lists nodes where the Pod might be able to run. // // The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced. @@ -929,6 +1056,12 @@ func (o PodSchedulingSpecPatchPtrOutput) ToPodSchedulingSpecPatchPtrOutputWithCo return o } +func (o PodSchedulingSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingSpecPatch] { + return pulumix.Output[*PodSchedulingSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingSpecPatchPtrOutput) Elem() PodSchedulingSpecPatchOutput { return o.ApplyT(func(v *PodSchedulingSpecPatch) PodSchedulingSpecPatch { if v != nil { @@ -996,6 +1129,12 @@ func (i PodSchedulingStatusArgs) ToPodSchedulingStatusOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingStatusOutput) } +func (i PodSchedulingStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingStatus] { + return pulumix.Output[PodSchedulingStatus]{ + OutputState: i.ToPodSchedulingStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodSchedulingStatusArgs) ToPodSchedulingStatusPtrOutput() PodSchedulingStatusPtrOutput { return i.ToPodSchedulingStatusPtrOutputWithContext(context.Background()) } @@ -1037,6 +1176,12 @@ func (i *podSchedulingStatusPtrType) ToPodSchedulingStatusPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingStatusPtrOutput) } +func (i *podSchedulingStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingStatus] { + return pulumix.Output[*PodSchedulingStatus]{ + OutputState: i.ToPodSchedulingStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingStatus describes where resources for the Pod can be allocated. type PodSchedulingStatusOutput struct{ *pulumi.OutputState } @@ -1062,6 +1207,12 @@ func (o PodSchedulingStatusOutput) ToPodSchedulingStatusPtrOutputWithContext(ctx }).(PodSchedulingStatusPtrOutput) } +func (o PodSchedulingStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingStatus] { + return pulumix.Output[PodSchedulingStatus]{ + OutputState: o.OutputState, + } +} + // ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode. func (o PodSchedulingStatusOutput) ResourceClaims() ResourceClaimSchedulingStatusArrayOutput { return o.ApplyT(func(v PodSchedulingStatus) []ResourceClaimSchedulingStatus { return v.ResourceClaims }).(ResourceClaimSchedulingStatusArrayOutput) @@ -1081,6 +1232,12 @@ func (o PodSchedulingStatusPtrOutput) ToPodSchedulingStatusPtrOutputWithContext( return o } +func (o PodSchedulingStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingStatus] { + return pulumix.Output[*PodSchedulingStatus]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingStatusPtrOutput) Elem() PodSchedulingStatusOutput { return o.ApplyT(func(v *PodSchedulingStatus) PodSchedulingStatus { if v != nil { @@ -1136,6 +1293,12 @@ func (i PodSchedulingStatusPatchArgs) ToPodSchedulingStatusPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingStatusPatchOutput) } +func (i PodSchedulingStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingStatusPatch] { + return pulumix.Output[PodSchedulingStatusPatch]{ + OutputState: i.ToPodSchedulingStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSchedulingStatusPatchArgs) ToPodSchedulingStatusPatchPtrOutput() PodSchedulingStatusPatchPtrOutput { return i.ToPodSchedulingStatusPatchPtrOutputWithContext(context.Background()) } @@ -1177,6 +1340,12 @@ func (i *podSchedulingStatusPatchPtrType) ToPodSchedulingStatusPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingStatusPatchPtrOutput) } +func (i *podSchedulingStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingStatusPatch] { + return pulumix.Output[*PodSchedulingStatusPatch]{ + OutputState: i.ToPodSchedulingStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingStatus describes where resources for the Pod can be allocated. type PodSchedulingStatusPatchOutput struct{ *pulumi.OutputState } @@ -1202,6 +1371,12 @@ func (o PodSchedulingStatusPatchOutput) ToPodSchedulingStatusPatchPtrOutputWithC }).(PodSchedulingStatusPatchPtrOutput) } +func (o PodSchedulingStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingStatusPatch] { + return pulumix.Output[PodSchedulingStatusPatch]{ + OutputState: o.OutputState, + } +} + // ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode. func (o PodSchedulingStatusPatchOutput) ResourceClaims() ResourceClaimSchedulingStatusPatchArrayOutput { return o.ApplyT(func(v PodSchedulingStatusPatch) []ResourceClaimSchedulingStatusPatch { return v.ResourceClaims }).(ResourceClaimSchedulingStatusPatchArrayOutput) @@ -1221,6 +1396,12 @@ func (o PodSchedulingStatusPatchPtrOutput) ToPodSchedulingStatusPatchPtrOutputWi return o } +func (o PodSchedulingStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingStatusPatch] { + return pulumix.Output[*PodSchedulingStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingStatusPatchPtrOutput) Elem() PodSchedulingStatusPatchOutput { return o.ApplyT(func(v *PodSchedulingStatusPatch) PodSchedulingStatusPatch { if v != nil { @@ -1296,6 +1477,12 @@ func (i ResourceClaimTypeArgs) ToResourceClaimTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTypeOutput) } +func (i ResourceClaimTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimType] { + return pulumix.Output[ResourceClaimType]{ + OutputState: i.ToResourceClaimTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTypeArrayInput is an input type that accepts ResourceClaimTypeArray and ResourceClaimTypeArrayOutput values. // You can construct a concrete instance of `ResourceClaimTypeArrayInput` via: // @@ -1321,6 +1508,12 @@ func (i ResourceClaimTypeArray) ToResourceClaimTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTypeArrayOutput) } +func (i ResourceClaimTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimType] { + return pulumix.Output[[]ResourceClaimType]{ + OutputState: i.ToResourceClaimTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -1338,6 +1531,12 @@ func (o ResourceClaimTypeOutput) ToResourceClaimTypeOutputWithContext(ctx contex return o } +func (o ResourceClaimTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimType] { + return pulumix.Output[ResourceClaimType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1377,6 +1576,12 @@ func (o ResourceClaimTypeArrayOutput) ToResourceClaimTypeArrayOutputWithContext( return o } +func (o ResourceClaimTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimType] { + return pulumix.Output[[]ResourceClaimType]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTypeArrayOutput) Index(i pulumi.IntInput) ResourceClaimTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimType { return vs[0].([]ResourceClaimType)[vs[1].(int)] @@ -1430,6 +1635,12 @@ func (i ResourceClaimConsumerReferenceArgs) ToResourceClaimConsumerReferenceOutp return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferenceOutput) } +func (i ResourceClaimConsumerReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReference] { + return pulumix.Output[ResourceClaimConsumerReference]{ + OutputState: i.ToResourceClaimConsumerReferenceOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReferenceArrayInput is an input type that accepts ResourceClaimConsumerReferenceArray and ResourceClaimConsumerReferenceArrayOutput values. // You can construct a concrete instance of `ResourceClaimConsumerReferenceArrayInput` via: // @@ -1455,6 +1666,12 @@ func (i ResourceClaimConsumerReferenceArray) ToResourceClaimConsumerReferenceArr return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferenceArrayOutput) } +func (i ResourceClaimConsumerReferenceArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReference] { + return pulumix.Output[[]ResourceClaimConsumerReference]{ + OutputState: i.ToResourceClaimConsumerReferenceArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim. type ResourceClaimConsumerReferenceOutput struct{ *pulumi.OutputState } @@ -1470,6 +1687,12 @@ func (o ResourceClaimConsumerReferenceOutput) ToResourceClaimConsumerReferenceOu return o } +func (o ResourceClaimConsumerReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReference] { + return pulumix.Output[ResourceClaimConsumerReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimConsumerReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimConsumerReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1504,6 +1727,12 @@ func (o ResourceClaimConsumerReferenceArrayOutput) ToResourceClaimConsumerRefere return o } +func (o ResourceClaimConsumerReferenceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReference] { + return pulumix.Output[[]ResourceClaimConsumerReference]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimConsumerReferenceArrayOutput) Index(i pulumi.IntInput) ResourceClaimConsumerReferenceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimConsumerReference { return vs[0].([]ResourceClaimConsumerReference)[vs[1].(int)] @@ -1557,6 +1786,12 @@ func (i ResourceClaimConsumerReferencePatchArgs) ToResourceClaimConsumerReferenc return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferencePatchOutput) } +func (i ResourceClaimConsumerReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReferencePatch] { + return pulumix.Output[ResourceClaimConsumerReferencePatch]{ + OutputState: i.ToResourceClaimConsumerReferencePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReferencePatchArrayInput is an input type that accepts ResourceClaimConsumerReferencePatchArray and ResourceClaimConsumerReferencePatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimConsumerReferencePatchArrayInput` via: // @@ -1582,6 +1817,12 @@ func (i ResourceClaimConsumerReferencePatchArray) ToResourceClaimConsumerReferen return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferencePatchArrayOutput) } +func (i ResourceClaimConsumerReferencePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReferencePatch] { + return pulumix.Output[[]ResourceClaimConsumerReferencePatch]{ + OutputState: i.ToResourceClaimConsumerReferencePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim. type ResourceClaimConsumerReferencePatchOutput struct{ *pulumi.OutputState } @@ -1597,6 +1838,12 @@ func (o ResourceClaimConsumerReferencePatchOutput) ToResourceClaimConsumerRefere return o } +func (o ResourceClaimConsumerReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReferencePatch] { + return pulumix.Output[ResourceClaimConsumerReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimConsumerReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimConsumerReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1631,6 +1878,12 @@ func (o ResourceClaimConsumerReferencePatchArrayOutput) ToResourceClaimConsumerR return o } +func (o ResourceClaimConsumerReferencePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReferencePatch] { + return pulumix.Output[[]ResourceClaimConsumerReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimConsumerReferencePatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimConsumerReferencePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimConsumerReferencePatch { return vs[0].([]ResourceClaimConsumerReferencePatch)[vs[1].(int)] @@ -1684,6 +1937,12 @@ func (i ResourceClaimListTypeArgs) ToResourceClaimListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListTypeOutput) } +func (i ResourceClaimListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimListType] { + return pulumix.Output[ResourceClaimListType]{ + OutputState: i.ToResourceClaimListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimList is a collection of claims. type ResourceClaimListTypeOutput struct{ *pulumi.OutputState } @@ -1699,6 +1958,12 @@ func (o ResourceClaimListTypeOutput) ToResourceClaimListTypeOutputWithContext(ct return o } +func (o ResourceClaimListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimListType] { + return pulumix.Output[ResourceClaimListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1762,6 +2027,12 @@ func (i ResourceClaimParametersReferenceArgs) ToResourceClaimParametersReference return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferenceOutput) } +func (i ResourceClaimParametersReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReference] { + return pulumix.Output[ResourceClaimParametersReference]{ + OutputState: i.ToResourceClaimParametersReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimParametersReferenceArgs) ToResourceClaimParametersReferencePtrOutput() ResourceClaimParametersReferencePtrOutput { return i.ToResourceClaimParametersReferencePtrOutputWithContext(context.Background()) } @@ -1803,6 +2074,12 @@ func (i *resourceClaimParametersReferencePtrType) ToResourceClaimParametersRefer return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferencePtrOutput) } +func (i *resourceClaimParametersReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReference] { + return pulumix.Output[*ResourceClaimParametersReference]{ + OutputState: i.ToResourceClaimParametersReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim. type ResourceClaimParametersReferenceOutput struct{ *pulumi.OutputState } @@ -1828,6 +2105,12 @@ func (o ResourceClaimParametersReferenceOutput) ToResourceClaimParametersReferen }).(ResourceClaimParametersReferencePtrOutput) } +func (o ResourceClaimParametersReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReference] { + return pulumix.Output[ResourceClaimParametersReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimParametersReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimParametersReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1857,6 +2140,12 @@ func (o ResourceClaimParametersReferencePtrOutput) ToResourceClaimParametersRefe return o } +func (o ResourceClaimParametersReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReference] { + return pulumix.Output[*ResourceClaimParametersReference]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimParametersReferencePtrOutput) Elem() ResourceClaimParametersReferenceOutput { return o.ApplyT(func(v *ResourceClaimParametersReference) ResourceClaimParametersReference { if v != nil { @@ -1940,6 +2229,12 @@ func (i ResourceClaimParametersReferencePatchArgs) ToResourceClaimParametersRefe return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferencePatchOutput) } +func (i ResourceClaimParametersReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReferencePatch] { + return pulumix.Output[ResourceClaimParametersReferencePatch]{ + OutputState: i.ToResourceClaimParametersReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimParametersReferencePatchArgs) ToResourceClaimParametersReferencePatchPtrOutput() ResourceClaimParametersReferencePatchPtrOutput { return i.ToResourceClaimParametersReferencePatchPtrOutputWithContext(context.Background()) } @@ -1981,6 +2276,12 @@ func (i *resourceClaimParametersReferencePatchPtrType) ToResourceClaimParameters return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferencePatchPtrOutput) } +func (i *resourceClaimParametersReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReferencePatch] { + return pulumix.Output[*ResourceClaimParametersReferencePatch]{ + OutputState: i.ToResourceClaimParametersReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim. type ResourceClaimParametersReferencePatchOutput struct{ *pulumi.OutputState } @@ -2006,6 +2307,12 @@ func (o ResourceClaimParametersReferencePatchOutput) ToResourceClaimParametersRe }).(ResourceClaimParametersReferencePatchPtrOutput) } +func (o ResourceClaimParametersReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReferencePatch] { + return pulumix.Output[ResourceClaimParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimParametersReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimParametersReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -2035,6 +2342,12 @@ func (o ResourceClaimParametersReferencePatchPtrOutput) ToResourceClaimParameter return o } +func (o ResourceClaimParametersReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReferencePatch] { + return pulumix.Output[*ResourceClaimParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimParametersReferencePatchPtrOutput) Elem() ResourceClaimParametersReferencePatchOutput { return o.ApplyT(func(v *ResourceClaimParametersReferencePatch) ResourceClaimParametersReferencePatch { if v != nil { @@ -2130,6 +2443,12 @@ func (i ResourceClaimPatchTypeArgs) ToResourceClaimPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchTypeOutput) } +func (i ResourceClaimPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimPatchType] { + return pulumix.Output[ResourceClaimPatchType]{ + OutputState: i.ToResourceClaimPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -2147,6 +2466,12 @@ func (o ResourceClaimPatchTypeOutput) ToResourceClaimPatchTypeOutputWithContext( return o } +func (o ResourceClaimPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimPatchType] { + return pulumix.Output[ResourceClaimPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2215,6 +2540,12 @@ func (i ResourceClaimSchedulingStatusArgs) ToResourceClaimSchedulingStatusOutput return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusOutput) } +func (i ResourceClaimSchedulingStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatus] { + return pulumix.Output[ResourceClaimSchedulingStatus]{ + OutputState: i.ToResourceClaimSchedulingStatusOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatusArrayInput is an input type that accepts ResourceClaimSchedulingStatusArray and ResourceClaimSchedulingStatusArrayOutput values. // You can construct a concrete instance of `ResourceClaimSchedulingStatusArrayInput` via: // @@ -2240,6 +2571,12 @@ func (i ResourceClaimSchedulingStatusArray) ToResourceClaimSchedulingStatusArray return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusArrayOutput) } +func (i ResourceClaimSchedulingStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatus] { + return pulumix.Output[[]ResourceClaimSchedulingStatus]{ + OutputState: i.ToResourceClaimSchedulingStatusArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode. type ResourceClaimSchedulingStatusOutput struct{ *pulumi.OutputState } @@ -2255,6 +2592,12 @@ func (o ResourceClaimSchedulingStatusOutput) ToResourceClaimSchedulingStatusOutp return o } +func (o ResourceClaimSchedulingStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatus] { + return pulumix.Output[ResourceClaimSchedulingStatus]{ + OutputState: o.OutputState, + } +} + // Name matches the pod.spec.resourceClaims[*].Name field. func (o ResourceClaimSchedulingStatusOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSchedulingStatus) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -2281,6 +2624,12 @@ func (o ResourceClaimSchedulingStatusArrayOutput) ToResourceClaimSchedulingStatu return o } +func (o ResourceClaimSchedulingStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatus] { + return pulumix.Output[[]ResourceClaimSchedulingStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimSchedulingStatusArrayOutput) Index(i pulumi.IntInput) ResourceClaimSchedulingStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimSchedulingStatus { return vs[0].([]ResourceClaimSchedulingStatus)[vs[1].(int)] @@ -2330,6 +2679,12 @@ func (i ResourceClaimSchedulingStatusPatchArgs) ToResourceClaimSchedulingStatusP return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusPatchOutput) } +func (i ResourceClaimSchedulingStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[ResourceClaimSchedulingStatusPatch]{ + OutputState: i.ToResourceClaimSchedulingStatusPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatusPatchArrayInput is an input type that accepts ResourceClaimSchedulingStatusPatchArray and ResourceClaimSchedulingStatusPatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimSchedulingStatusPatchArrayInput` via: // @@ -2355,6 +2710,12 @@ func (i ResourceClaimSchedulingStatusPatchArray) ToResourceClaimSchedulingStatus return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusPatchArrayOutput) } +func (i ResourceClaimSchedulingStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[[]ResourceClaimSchedulingStatusPatch]{ + OutputState: i.ToResourceClaimSchedulingStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode. type ResourceClaimSchedulingStatusPatchOutput struct{ *pulumi.OutputState } @@ -2370,6 +2731,12 @@ func (o ResourceClaimSchedulingStatusPatchOutput) ToResourceClaimSchedulingStatu return o } +func (o ResourceClaimSchedulingStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[ResourceClaimSchedulingStatusPatch]{ + OutputState: o.OutputState, + } +} + // Name matches the pod.spec.resourceClaims[*].Name field. func (o ResourceClaimSchedulingStatusPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSchedulingStatusPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -2396,6 +2763,12 @@ func (o ResourceClaimSchedulingStatusPatchArrayOutput) ToResourceClaimScheduling return o } +func (o ResourceClaimSchedulingStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[[]ResourceClaimSchedulingStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimSchedulingStatusPatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimSchedulingStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimSchedulingStatusPatch { return vs[0].([]ResourceClaimSchedulingStatusPatch)[vs[1].(int)] @@ -2449,6 +2822,12 @@ func (i ResourceClaimSpecArgs) ToResourceClaimSpecOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSpecOutput) } +func (i ResourceClaimSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpec] { + return pulumix.Output[ResourceClaimSpec]{ + OutputState: i.ToResourceClaimSpecOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSpec defines how a resource is to be allocated. type ResourceClaimSpecOutput struct{ *pulumi.OutputState } @@ -2464,6 +2843,12 @@ func (o ResourceClaimSpecOutput) ToResourceClaimSpecOutputWithContext(ctx contex return o } +func (o ResourceClaimSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpec] { + return pulumix.Output[ResourceClaimSpec]{ + OutputState: o.OutputState, + } +} + // Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default. func (o ResourceClaimSpecOutput) AllocationMode() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSpec) *string { return v.AllocationMode }).(pulumi.StringPtrOutput) @@ -2528,6 +2913,12 @@ func (i ResourceClaimSpecPatchArgs) ToResourceClaimSpecPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSpecPatchOutput) } +func (i ResourceClaimSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpecPatch] { + return pulumix.Output[ResourceClaimSpecPatch]{ + OutputState: i.ToResourceClaimSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimSpecPatchArgs) ToResourceClaimSpecPatchPtrOutput() ResourceClaimSpecPatchPtrOutput { return i.ToResourceClaimSpecPatchPtrOutputWithContext(context.Background()) } @@ -2569,6 +2960,12 @@ func (i *resourceClaimSpecPatchPtrType) ToResourceClaimSpecPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSpecPatchPtrOutput) } +func (i *resourceClaimSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimSpecPatch] { + return pulumix.Output[*ResourceClaimSpecPatch]{ + OutputState: i.ToResourceClaimSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSpec defines how a resource is to be allocated. type ResourceClaimSpecPatchOutput struct{ *pulumi.OutputState } @@ -2594,6 +2991,12 @@ func (o ResourceClaimSpecPatchOutput) ToResourceClaimSpecPatchPtrOutputWithConte }).(ResourceClaimSpecPatchPtrOutput) } +func (o ResourceClaimSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpecPatch] { + return pulumix.Output[ResourceClaimSpecPatch]{ + OutputState: o.OutputState, + } +} + // Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default. func (o ResourceClaimSpecPatchOutput) AllocationMode() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSpecPatch) *string { return v.AllocationMode }).(pulumi.StringPtrOutput) @@ -2625,6 +3028,12 @@ func (o ResourceClaimSpecPatchPtrOutput) ToResourceClaimSpecPatchPtrOutputWithCo return o } +func (o ResourceClaimSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimSpecPatch] { + return pulumix.Output[*ResourceClaimSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimSpecPatchPtrOutput) Elem() ResourceClaimSpecPatchOutput { return o.ApplyT(func(v *ResourceClaimSpecPatch) ResourceClaimSpecPatch { if v != nil { @@ -2726,6 +3135,12 @@ func (i ResourceClaimStatusArgs) ToResourceClaimStatusOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusOutput) } +func (i ResourceClaimStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatus] { + return pulumix.Output[ResourceClaimStatus]{ + OutputState: i.ToResourceClaimStatusOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimStatusArgs) ToResourceClaimStatusPtrOutput() ResourceClaimStatusPtrOutput { return i.ToResourceClaimStatusPtrOutputWithContext(context.Background()) } @@ -2767,6 +3182,12 @@ func (i *resourceClaimStatusPtrType) ToResourceClaimStatusPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPtrOutput) } +func (i *resourceClaimStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatus] { + return pulumix.Output[*ResourceClaimStatus]{ + OutputState: i.ToResourceClaimStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are. type ResourceClaimStatusOutput struct{ *pulumi.OutputState } @@ -2792,6 +3213,12 @@ func (o ResourceClaimStatusOutput) ToResourceClaimStatusPtrOutputWithContext(ctx }).(ResourceClaimStatusPtrOutput) } +func (o ResourceClaimStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatus] { + return pulumix.Output[ResourceClaimStatus]{ + OutputState: o.OutputState, + } +} + // Allocation is set by the resource driver once a resource has been allocated successfully. If this is not specified, the resource is not yet allocated. func (o ResourceClaimStatusOutput) Allocation() AllocationResultPtrOutput { return o.ApplyT(func(v ResourceClaimStatus) *AllocationResult { return v.Allocation }).(AllocationResultPtrOutput) @@ -2832,6 +3259,12 @@ func (o ResourceClaimStatusPtrOutput) ToResourceClaimStatusPtrOutputWithContext( return o } +func (o ResourceClaimStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatus] { + return pulumix.Output[*ResourceClaimStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimStatusPtrOutput) Elem() ResourceClaimStatusOutput { return o.ApplyT(func(v *ResourceClaimStatus) ResourceClaimStatus { if v != nil { @@ -2947,6 +3380,12 @@ func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchOutput) } +func (i ResourceClaimStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatusPatch] { + return pulumix.Output[ResourceClaimStatusPatch]{ + OutputState: i.ToResourceClaimStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput { return i.ToResourceClaimStatusPatchPtrOutputWithContext(context.Background()) } @@ -2988,6 +3427,12 @@ func (i *resourceClaimStatusPatchPtrType) ToResourceClaimStatusPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchPtrOutput) } +func (i *resourceClaimStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatusPatch] { + return pulumix.Output[*ResourceClaimStatusPatch]{ + OutputState: i.ToResourceClaimStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are. type ResourceClaimStatusPatchOutput struct{ *pulumi.OutputState } @@ -3013,6 +3458,12 @@ func (o ResourceClaimStatusPatchOutput) ToResourceClaimStatusPatchPtrOutputWithC }).(ResourceClaimStatusPatchPtrOutput) } +func (o ResourceClaimStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatusPatch] { + return pulumix.Output[ResourceClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + // Allocation is set by the resource driver once a resource has been allocated successfully. If this is not specified, the resource is not yet allocated. func (o ResourceClaimStatusPatchOutput) Allocation() AllocationResultPatchPtrOutput { return o.ApplyT(func(v ResourceClaimStatusPatch) *AllocationResultPatch { return v.Allocation }).(AllocationResultPatchPtrOutput) @@ -3053,6 +3504,12 @@ func (o ResourceClaimStatusPatchPtrOutput) ToResourceClaimStatusPatchPtrOutputWi return o } +func (o ResourceClaimStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatusPatch] { + return pulumix.Output[*ResourceClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimStatusPatchPtrOutput) Elem() ResourceClaimStatusPatchOutput { return o.ApplyT(func(v *ResourceClaimStatusPatch) ResourceClaimStatusPatch { if v != nil { @@ -3160,6 +3617,12 @@ func (i ResourceClaimTemplateTypeArgs) ToResourceClaimTemplateTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateTypeOutput) } +func (i ResourceClaimTemplateTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateType] { + return pulumix.Output[ResourceClaimTemplateType]{ + OutputState: i.ToResourceClaimTemplateTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateTypeArrayInput is an input type that accepts ResourceClaimTemplateTypeArray and ResourceClaimTemplateTypeArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplateTypeArrayInput` via: // @@ -3185,6 +3648,12 @@ func (i ResourceClaimTemplateTypeArray) ToResourceClaimTemplateTypeArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateTypeArrayOutput) } +func (i ResourceClaimTemplateTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimTemplateType] { + return pulumix.Output[[]ResourceClaimTemplateType]{ + OutputState: i.ToResourceClaimTemplateTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplate is used to produce ResourceClaim objects. type ResourceClaimTemplateTypeOutput struct{ *pulumi.OutputState } @@ -3200,6 +3669,12 @@ func (o ResourceClaimTemplateTypeOutput) ToResourceClaimTemplateTypeOutputWithCo return o } +func (o ResourceClaimTemplateTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateType] { + return pulumix.Output[ResourceClaimTemplateType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3236,6 +3711,12 @@ func (o ResourceClaimTemplateTypeArrayOutput) ToResourceClaimTemplateTypeArrayOu return o } +func (o ResourceClaimTemplateTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimTemplateType] { + return pulumix.Output[[]ResourceClaimTemplateType]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateTypeArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimTemplateType { return vs[0].([]ResourceClaimTemplateType)[vs[1].(int)] @@ -3289,6 +3770,12 @@ func (i ResourceClaimTemplateListTypeArgs) ToResourceClaimTemplateListTypeOutput return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListTypeOutput) } +func (i ResourceClaimTemplateListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateListType] { + return pulumix.Output[ResourceClaimTemplateListType]{ + OutputState: i.ToResourceClaimTemplateListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateList is a collection of claim templates. type ResourceClaimTemplateListTypeOutput struct{ *pulumi.OutputState } @@ -3304,6 +3791,12 @@ func (o ResourceClaimTemplateListTypeOutput) ToResourceClaimTemplateListTypeOutp return o } +func (o ResourceClaimTemplateListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateListType] { + return pulumix.Output[ResourceClaimTemplateListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3375,6 +3868,12 @@ func (i ResourceClaimTemplatePatchTypeArgs) ToResourceClaimTemplatePatchTypeOutp return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchTypeOutput) } +func (i ResourceClaimTemplatePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplatePatchType] { + return pulumix.Output[ResourceClaimTemplatePatchType]{ + OutputState: i.ToResourceClaimTemplatePatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplate is used to produce ResourceClaim objects. type ResourceClaimTemplatePatchTypeOutput struct{ *pulumi.OutputState } @@ -3390,6 +3889,12 @@ func (o ResourceClaimTemplatePatchTypeOutput) ToResourceClaimTemplatePatchTypeOu return o } +func (o ResourceClaimTemplatePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplatePatchType] { + return pulumix.Output[ResourceClaimTemplatePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplatePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimTemplatePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3451,6 +3956,12 @@ func (i ResourceClaimTemplateSpecArgs) ToResourceClaimTemplateSpecOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecOutput) } +func (i ResourceClaimTemplateSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpec] { + return pulumix.Output[ResourceClaimTemplateSpec]{ + OutputState: i.ToResourceClaimTemplateSpecOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim. type ResourceClaimTemplateSpecOutput struct{ *pulumi.OutputState } @@ -3466,6 +3977,12 @@ func (o ResourceClaimTemplateSpecOutput) ToResourceClaimTemplateSpecOutputWithCo return o } +func (o ResourceClaimTemplateSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpec] { + return pulumix.Output[ResourceClaimTemplateSpec]{ + OutputState: o.OutputState, + } +} + // ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. func (o ResourceClaimTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -3515,6 +4032,12 @@ func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchOutp return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchOutput) } +func (i ResourceClaimTemplateSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpecPatch] { + return pulumix.Output[ResourceClaimTemplateSpecPatch]{ + OutputState: i.ToResourceClaimTemplateSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput { return i.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(context.Background()) } @@ -3556,6 +4079,12 @@ func (i *resourceClaimTemplateSpecPatchPtrType) ToResourceClaimTemplateSpecPatch return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchPtrOutput) } +func (i *resourceClaimTemplateSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateSpecPatch] { + return pulumix.Output[*ResourceClaimTemplateSpecPatch]{ + OutputState: i.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim. type ResourceClaimTemplateSpecPatchOutput struct{ *pulumi.OutputState } @@ -3581,6 +4110,12 @@ func (o ResourceClaimTemplateSpecPatchOutput) ToResourceClaimTemplateSpecPatchPt }).(ResourceClaimTemplateSpecPatchPtrOutput) } +func (o ResourceClaimTemplateSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpecPatch] { + return pulumix.Output[ResourceClaimTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + // ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. func (o ResourceClaimTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -3605,6 +4140,12 @@ func (o ResourceClaimTemplateSpecPatchPtrOutput) ToResourceClaimTemplateSpecPatc return o } +func (o ResourceClaimTemplateSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateSpecPatch] { + return pulumix.Output[*ResourceClaimTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateSpecPatchPtrOutput) Elem() ResourceClaimTemplateSpecPatchOutput { return o.ApplyT(func(v *ResourceClaimTemplateSpecPatch) ResourceClaimTemplateSpecPatch { if v != nil { @@ -3702,6 +4243,12 @@ func (i ResourceClassTypeArgs) ToResourceClassTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceClassTypeOutput) } +func (i ResourceClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassType] { + return pulumix.Output[ResourceClassType]{ + OutputState: i.ToResourceClassTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClassTypeArrayInput is an input type that accepts ResourceClassTypeArray and ResourceClassTypeArrayOutput values. // You can construct a concrete instance of `ResourceClassTypeArrayInput` via: // @@ -3727,6 +4274,12 @@ func (i ResourceClassTypeArray) ToResourceClassTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClassTypeArrayOutput) } +func (i ResourceClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClassType] { + return pulumix.Output[[]ResourceClassType]{ + OutputState: i.ToResourceClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClass is used by administrators to influence how resources are allocated. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -3744,6 +4297,12 @@ func (o ResourceClassTypeOutput) ToResourceClassTypeOutputWithContext(ctx contex return o } +func (o ResourceClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassType] { + return pulumix.Output[ResourceClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3792,6 +4351,12 @@ func (o ResourceClassTypeArrayOutput) ToResourceClassTypeArrayOutputWithContext( return o } +func (o ResourceClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClassType] { + return pulumix.Output[[]ResourceClassType]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassTypeArrayOutput) Index(i pulumi.IntInput) ResourceClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClassType { return vs[0].([]ResourceClassType)[vs[1].(int)] @@ -3845,6 +4410,12 @@ func (i ResourceClassListTypeArgs) ToResourceClassListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListTypeOutput) } +func (i ResourceClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassListType] { + return pulumix.Output[ResourceClassListType]{ + OutputState: i.ToResourceClassListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClassList is a collection of classes. type ResourceClassListTypeOutput struct{ *pulumi.OutputState } @@ -3860,6 +4431,12 @@ func (o ResourceClassListTypeOutput) ToResourceClassListTypeOutputWithContext(ct return o } +func (o ResourceClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassListType] { + return pulumix.Output[ResourceClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3927,6 +4504,12 @@ func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReference return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferenceOutput) } +func (i ResourceClassParametersReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReference] { + return pulumix.Output[ResourceClassParametersReference]{ + OutputState: i.ToResourceClassParametersReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput { return i.ToResourceClassParametersReferencePtrOutputWithContext(context.Background()) } @@ -3968,6 +4551,12 @@ func (i *resourceClassParametersReferencePtrType) ToResourceClassParametersRefer return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePtrOutput) } +func (i *resourceClassParametersReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReference] { + return pulumix.Output[*ResourceClassParametersReference]{ + OutputState: i.ToResourceClassParametersReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass. type ResourceClassParametersReferenceOutput struct{ *pulumi.OutputState } @@ -3993,6 +4582,12 @@ func (o ResourceClassParametersReferenceOutput) ToResourceClassParametersReferen }).(ResourceClassParametersReferencePtrOutput) } +func (o ResourceClassParametersReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReference] { + return pulumix.Output[ResourceClassParametersReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClassParametersReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassParametersReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -4027,6 +4622,12 @@ func (o ResourceClassParametersReferencePtrOutput) ToResourceClassParametersRefe return o } +func (o ResourceClassParametersReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReference] { + return pulumix.Output[*ResourceClassParametersReference]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassParametersReferencePtrOutput) Elem() ResourceClassParametersReferenceOutput { return o.ApplyT(func(v *ResourceClassParametersReference) ResourceClassParametersReference { if v != nil { @@ -4124,6 +4725,12 @@ func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersRefe return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchOutput) } +func (i ResourceClassParametersReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReferencePatch] { + return pulumix.Output[ResourceClassParametersReferencePatch]{ + OutputState: i.ToResourceClassParametersReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput { return i.ToResourceClassParametersReferencePatchPtrOutputWithContext(context.Background()) } @@ -4165,6 +4772,12 @@ func (i *resourceClassParametersReferencePatchPtrType) ToResourceClassParameters return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchPtrOutput) } +func (i *resourceClassParametersReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReferencePatch] { + return pulumix.Output[*ResourceClassParametersReferencePatch]{ + OutputState: i.ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass. type ResourceClassParametersReferencePatchOutput struct{ *pulumi.OutputState } @@ -4190,6 +4803,12 @@ func (o ResourceClassParametersReferencePatchOutput) ToResourceClassParametersRe }).(ResourceClassParametersReferencePatchPtrOutput) } +func (o ResourceClassParametersReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReferencePatch] { + return pulumix.Output[ResourceClassParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClassParametersReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassParametersReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -4224,6 +4843,12 @@ func (o ResourceClassParametersReferencePatchPtrOutput) ToResourceClassParameter return o } +func (o ResourceClassParametersReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReferencePatch] { + return pulumix.Output[*ResourceClassParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassParametersReferencePatchPtrOutput) Elem() ResourceClassParametersReferencePatchOutput { return o.ApplyT(func(v *ResourceClassParametersReferencePatch) ResourceClassParametersReferencePatch { if v != nil { @@ -4341,6 +4966,12 @@ func (i ResourceClassPatchTypeArgs) ToResourceClassPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchTypeOutput) } +func (i ResourceClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassPatchType] { + return pulumix.Output[ResourceClassPatchType]{ + OutputState: i.ToResourceClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClass is used by administrators to influence how resources are allocated. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -4358,6 +4989,12 @@ func (o ResourceClassPatchTypeOutput) ToResourceClassPatchTypeOutputWithContext( return o } +func (o ResourceClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassPatchType] { + return pulumix.Output[ResourceClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClaim.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClaim.go index de77551816..e733502ac8 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClaim.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClaim.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are. @@ -127,6 +128,12 @@ func (i *ResourceClaim) ToResourceClaimOutputWithContext(ctx context.Context) Re return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimOutput) } +func (i *ResourceClaim) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaim] { + return pulumix.Output[*ResourceClaim]{ + OutputState: i.ToResourceClaimOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimArrayInput is an input type that accepts ResourceClaimArray and ResourceClaimArrayOutput values. // You can construct a concrete instance of `ResourceClaimArrayInput` via: // @@ -152,6 +159,12 @@ func (i ResourceClaimArray) ToResourceClaimArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimArrayOutput) } +func (i ResourceClaimArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaim] { + return pulumix.Output[[]*ResourceClaim]{ + OutputState: i.ToResourceClaimArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimMapInput is an input type that accepts ResourceClaimMap and ResourceClaimMapOutput values. // You can construct a concrete instance of `ResourceClaimMapInput` via: // @@ -177,6 +190,12 @@ func (i ResourceClaimMap) ToResourceClaimMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimMapOutput) } +func (i ResourceClaimMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaim] { + return pulumix.Output[map[string]*ResourceClaim]{ + OutputState: i.ToResourceClaimMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimOutput struct{ *pulumi.OutputState } func (ResourceClaimOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o ResourceClaimOutput) ToResourceClaimOutputWithContext(ctx context.Contex return o } +func (o ResourceClaimOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaim] { + return pulumix.Output[*ResourceClaim]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaim) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o ResourceClaimArrayOutput) ToResourceClaimArrayOutputWithContext(ctx cont return o } +func (o ResourceClaimArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaim] { + return pulumix.Output[[]*ResourceClaim]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimArrayOutput) Index(i pulumi.IntInput) ResourceClaimOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaim { return vs[0].([]*ResourceClaim)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o ResourceClaimMapOutput) ToResourceClaimMapOutputWithContext(ctx context. return o } +func (o ResourceClaimMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaim] { + return pulumix.Output[map[string]*ResourceClaim]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaim { return vs[0].(map[string]*ResourceClaim)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimList.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimList.go index 0de0deb866..17c335c54e 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimList.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaimList is a collection of claims. @@ -117,6 +118,12 @@ func (i *ResourceClaimList) ToResourceClaimListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListOutput) } +func (i *ResourceClaimList) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimList] { + return pulumix.Output[*ResourceClaimList]{ + OutputState: i.ToResourceClaimListOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimListArrayInput is an input type that accepts ResourceClaimListArray and ResourceClaimListArrayOutput values. // You can construct a concrete instance of `ResourceClaimListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceClaimListArray) ToResourceClaimListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListArrayOutput) } +func (i ResourceClaimListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimList] { + return pulumix.Output[[]*ResourceClaimList]{ + OutputState: i.ToResourceClaimListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimListMapInput is an input type that accepts ResourceClaimListMap and ResourceClaimListMapOutput values. // You can construct a concrete instance of `ResourceClaimListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceClaimListMap) ToResourceClaimListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListMapOutput) } +func (i ResourceClaimListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimList] { + return pulumix.Output[map[string]*ResourceClaimList]{ + OutputState: i.ToResourceClaimListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimListOutput struct{ *pulumi.OutputState } func (ResourceClaimListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceClaimListOutput) ToResourceClaimListOutputWithContext(ctx contex return o } +func (o ResourceClaimListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimList] { + return pulumix.Output[*ResourceClaimList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaimList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceClaimListArrayOutput) ToResourceClaimListArrayOutputWithContext( return o } +func (o ResourceClaimListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimList] { + return pulumix.Output[[]*ResourceClaimList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimListArrayOutput) Index(i pulumi.IntInput) ResourceClaimListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimList { return vs[0].([]*ResourceClaimList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceClaimListMapOutput) ToResourceClaimListMapOutputWithContext(ctx return o } +func (o ResourceClaimListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimList] { + return pulumix.Output[map[string]*ResourceClaimList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimListMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimList { return vs[0].(map[string]*ResourceClaimList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimPatch.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimPatch.go index fc7d3baf96..a94faa2653 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimPatch.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -129,6 +130,12 @@ func (i *ResourceClaimPatch) ToResourceClaimPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchOutput) } +func (i *ResourceClaimPatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimPatch] { + return pulumix.Output[*ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimPatchArrayInput is an input type that accepts ResourceClaimPatchArray and ResourceClaimPatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimPatchArrayInput` via: // @@ -154,6 +161,12 @@ func (i ResourceClaimPatchArray) ToResourceClaimPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchArrayOutput) } +func (i ResourceClaimPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimPatch] { + return pulumix.Output[[]*ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimPatchMapInput is an input type that accepts ResourceClaimPatchMap and ResourceClaimPatchMapOutput values. // You can construct a concrete instance of `ResourceClaimPatchMapInput` via: // @@ -179,6 +192,12 @@ func (i ResourceClaimPatchMap) ToResourceClaimPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchMapOutput) } +func (i ResourceClaimPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimPatch] { + return pulumix.Output[map[string]*ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimPatchOutput struct{ *pulumi.OutputState } func (ResourceClaimPatchOutput) ElementType() reflect.Type { @@ -193,6 +212,12 @@ func (o ResourceClaimPatchOutput) ToResourceClaimPatchOutputWithContext(ctx cont return o } +func (o ResourceClaimPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimPatch] { + return pulumix.Output[*ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceClaimPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -232,6 +257,12 @@ func (o ResourceClaimPatchArrayOutput) ToResourceClaimPatchArrayOutputWithContex return o } +func (o ResourceClaimPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimPatch] { + return pulumix.Output[[]*ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimPatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimPatch { return vs[0].([]*ResourceClaimPatch)[vs[1].(int)] @@ -252,6 +283,12 @@ func (o ResourceClaimPatchMapOutput) ToResourceClaimPatchMapOutputWithContext(ct return o } +func (o ResourceClaimPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimPatch] { + return pulumix.Output[map[string]*ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimPatchMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimPatch { return vs[0].(map[string]*ResourceClaimPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplate.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplate.go index 1cbd0b0be0..fac20d536d 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplate.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplate.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaimTemplate is used to produce ResourceClaim objects. @@ -129,6 +130,12 @@ func (i *ResourceClaimTemplate) ToResourceClaimTemplateOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateOutput) } +func (i *ResourceClaimTemplate) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplate] { + return pulumix.Output[*ResourceClaimTemplate]{ + OutputState: i.ToResourceClaimTemplateOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateArrayInput is an input type that accepts ResourceClaimTemplateArray and ResourceClaimTemplateArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplateArrayInput` via: // @@ -154,6 +161,12 @@ func (i ResourceClaimTemplateArray) ToResourceClaimTemplateArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateArrayOutput) } +func (i ResourceClaimTemplateArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplate] { + return pulumix.Output[[]*ResourceClaimTemplate]{ + OutputState: i.ToResourceClaimTemplateArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateMapInput is an input type that accepts ResourceClaimTemplateMap and ResourceClaimTemplateMapOutput values. // You can construct a concrete instance of `ResourceClaimTemplateMapInput` via: // @@ -179,6 +192,12 @@ func (i ResourceClaimTemplateMap) ToResourceClaimTemplateMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateMapOutput) } +func (i ResourceClaimTemplateMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplate] { + return pulumix.Output[map[string]*ResourceClaimTemplate]{ + OutputState: i.ToResourceClaimTemplateMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimTemplateOutput struct{ *pulumi.OutputState } func (ResourceClaimTemplateOutput) ElementType() reflect.Type { @@ -193,6 +212,12 @@ func (o ResourceClaimTemplateOutput) ToResourceClaimTemplateOutputWithContext(ct return o } +func (o ResourceClaimTemplateOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplate] { + return pulumix.Output[*ResourceClaimTemplate]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaimTemplate) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -229,6 +254,12 @@ func (o ResourceClaimTemplateArrayOutput) ToResourceClaimTemplateArrayOutputWith return o } +func (o ResourceClaimTemplateArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplate] { + return pulumix.Output[[]*ResourceClaimTemplate]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimTemplate { return vs[0].([]*ResourceClaimTemplate)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o ResourceClaimTemplateMapOutput) ToResourceClaimTemplateMapOutputWithCont return o } +func (o ResourceClaimTemplateMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplate] { + return pulumix.Output[map[string]*ResourceClaimTemplate]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimTemplateOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimTemplate { return vs[0].(map[string]*ResourceClaimTemplate)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplateList.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplateList.go index d842a75ae2..9b5c04f7da 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplateList.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplateList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaimTemplateList is a collection of claim templates. @@ -117,6 +118,12 @@ func (i *ResourceClaimTemplateList) ToResourceClaimTemplateListOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListOutput) } +func (i *ResourceClaimTemplateList) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateList] { + return pulumix.Output[*ResourceClaimTemplateList]{ + OutputState: i.ToResourceClaimTemplateListOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateListArrayInput is an input type that accepts ResourceClaimTemplateListArray and ResourceClaimTemplateListArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplateListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceClaimTemplateListArray) ToResourceClaimTemplateListArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListArrayOutput) } +func (i ResourceClaimTemplateListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplateList] { + return pulumix.Output[[]*ResourceClaimTemplateList]{ + OutputState: i.ToResourceClaimTemplateListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateListMapInput is an input type that accepts ResourceClaimTemplateListMap and ResourceClaimTemplateListMapOutput values. // You can construct a concrete instance of `ResourceClaimTemplateListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceClaimTemplateListMap) ToResourceClaimTemplateListMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListMapOutput) } +func (i ResourceClaimTemplateListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplateList] { + return pulumix.Output[map[string]*ResourceClaimTemplateList]{ + OutputState: i.ToResourceClaimTemplateListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimTemplateListOutput struct{ *pulumi.OutputState } func (ResourceClaimTemplateListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceClaimTemplateListOutput) ToResourceClaimTemplateListOutputWithCo return o } +func (o ResourceClaimTemplateListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateList] { + return pulumix.Output[*ResourceClaimTemplateList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaimTemplateList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceClaimTemplateListArrayOutput) ToResourceClaimTemplateListArrayOu return o } +func (o ResourceClaimTemplateListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplateList] { + return pulumix.Output[[]*ResourceClaimTemplateList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateListArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimTemplateList { return vs[0].([]*ResourceClaimTemplateList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceClaimTemplateListMapOutput) ToResourceClaimTemplateListMapOutput return o } +func (o ResourceClaimTemplateListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplateList] { + return pulumix.Output[map[string]*ResourceClaimTemplateList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateListMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimTemplateListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimTemplateList { return vs[0].(map[string]*ResourceClaimTemplateList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplatePatch.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplatePatch.go index 711e17cebb..303811af73 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplatePatch.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClaimTemplatePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -131,6 +132,12 @@ func (i *ResourceClaimTemplatePatch) ToResourceClaimTemplatePatchOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchOutput) } +func (i *ResourceClaimTemplatePatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplatePatch] { + return pulumix.Output[*ResourceClaimTemplatePatch]{ + OutputState: i.ToResourceClaimTemplatePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplatePatchArrayInput is an input type that accepts ResourceClaimTemplatePatchArray and ResourceClaimTemplatePatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplatePatchArrayInput` via: // @@ -156,6 +163,12 @@ func (i ResourceClaimTemplatePatchArray) ToResourceClaimTemplatePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchArrayOutput) } +func (i ResourceClaimTemplatePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplatePatch] { + return pulumix.Output[[]*ResourceClaimTemplatePatch]{ + OutputState: i.ToResourceClaimTemplatePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplatePatchMapInput is an input type that accepts ResourceClaimTemplatePatchMap and ResourceClaimTemplatePatchMapOutput values. // You can construct a concrete instance of `ResourceClaimTemplatePatchMapInput` via: // @@ -181,6 +194,12 @@ func (i ResourceClaimTemplatePatchMap) ToResourceClaimTemplatePatchMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchMapOutput) } +func (i ResourceClaimTemplatePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplatePatch] { + return pulumix.Output[map[string]*ResourceClaimTemplatePatch]{ + OutputState: i.ToResourceClaimTemplatePatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimTemplatePatchOutput struct{ *pulumi.OutputState } func (ResourceClaimTemplatePatchOutput) ElementType() reflect.Type { @@ -195,6 +214,12 @@ func (o ResourceClaimTemplatePatchOutput) ToResourceClaimTemplatePatchOutputWith return o } +func (o ResourceClaimTemplatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplatePatch] { + return pulumix.Output[*ResourceClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplatePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceClaimTemplatePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -231,6 +256,12 @@ func (o ResourceClaimTemplatePatchArrayOutput) ToResourceClaimTemplatePatchArray return o } +func (o ResourceClaimTemplatePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplatePatch] { + return pulumix.Output[[]*ResourceClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplatePatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplatePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimTemplatePatch { return vs[0].([]*ResourceClaimTemplatePatch)[vs[1].(int)] @@ -251,6 +282,12 @@ func (o ResourceClaimTemplatePatchMapOutput) ToResourceClaimTemplatePatchMapOutp return o } +func (o ResourceClaimTemplatePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplatePatch] { + return pulumix.Output[map[string]*ResourceClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplatePatchMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimTemplatePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimTemplatePatch { return vs[0].(map[string]*ResourceClaimTemplatePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClass.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClass.go index a7fdad3dd0..524a88e515 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClass.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClass.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClass is used by administrators to influence how resources are allocated. @@ -150,6 +151,12 @@ func (i *ResourceClass) ToResourceClassOutputWithContext(ctx context.Context) Re return pulumi.ToOutputWithContext(ctx, i).(ResourceClassOutput) } +func (i *ResourceClass) ToOutput(ctx context.Context) pulumix.Output[*ResourceClass] { + return pulumix.Output[*ResourceClass]{ + OutputState: i.ToResourceClassOutputWithContext(ctx).OutputState, + } +} + // ResourceClassArrayInput is an input type that accepts ResourceClassArray and ResourceClassArrayOutput values. // You can construct a concrete instance of `ResourceClassArrayInput` via: // @@ -175,6 +182,12 @@ func (i ResourceClassArray) ToResourceClassArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ResourceClassArrayOutput) } +func (i ResourceClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClass] { + return pulumix.Output[[]*ResourceClass]{ + OutputState: i.ToResourceClassArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClassMapInput is an input type that accepts ResourceClassMap and ResourceClassMapOutput values. // You can construct a concrete instance of `ResourceClassMapInput` via: // @@ -200,6 +213,12 @@ func (i ResourceClassMap) ToResourceClassMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClassMapOutput) } +func (i ResourceClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClass] { + return pulumix.Output[map[string]*ResourceClass]{ + OutputState: i.ToResourceClassMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClassOutput struct{ *pulumi.OutputState } func (ResourceClassOutput) ElementType() reflect.Type { @@ -214,6 +233,12 @@ func (o ResourceClassOutput) ToResourceClassOutputWithContext(ctx context.Contex return o } +func (o ResourceClassOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClass] { + return pulumix.Output[*ResourceClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -262,6 +287,12 @@ func (o ResourceClassArrayOutput) ToResourceClassArrayOutputWithContext(ctx cont return o } +func (o ResourceClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClass] { + return pulumix.Output[[]*ResourceClass]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassArrayOutput) Index(i pulumi.IntInput) ResourceClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClass { return vs[0].([]*ResourceClass)[vs[1].(int)] @@ -282,6 +313,12 @@ func (o ResourceClassMapOutput) ToResourceClassMapOutputWithContext(ctx context. return o } +func (o ResourceClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClass] { + return pulumix.Output[map[string]*ResourceClass]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassMapOutput) MapIndex(k pulumi.StringInput) ResourceClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClass { return vs[0].(map[string]*ResourceClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClassList.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClassList.go index eb989f07e2..ea17125a58 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClassList.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClassList is a collection of classes. @@ -117,6 +118,12 @@ func (i *ResourceClassList) ToResourceClassListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListOutput) } +func (i *ResourceClassList) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassList] { + return pulumix.Output[*ResourceClassList]{ + OutputState: i.ToResourceClassListOutputWithContext(ctx).OutputState, + } +} + // ResourceClassListArrayInput is an input type that accepts ResourceClassListArray and ResourceClassListArrayOutput values. // You can construct a concrete instance of `ResourceClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceClassListArray) ToResourceClassListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListArrayOutput) } +func (i ResourceClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassList] { + return pulumix.Output[[]*ResourceClassList]{ + OutputState: i.ToResourceClassListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClassListMapInput is an input type that accepts ResourceClassListMap and ResourceClassListMapOutput values. // You can construct a concrete instance of `ResourceClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceClassListMap) ToResourceClassListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListMapOutput) } +func (i ResourceClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassList] { + return pulumix.Output[map[string]*ResourceClassList]{ + OutputState: i.ToResourceClassListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClassListOutput struct{ *pulumi.OutputState } func (ResourceClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceClassListOutput) ToResourceClassListOutputWithContext(ctx contex return o } +func (o ResourceClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassList] { + return pulumix.Output[*ResourceClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceClassListArrayOutput) ToResourceClassListArrayOutputWithContext( return o } +func (o ResourceClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassList] { + return pulumix.Output[[]*ResourceClassList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassListArrayOutput) Index(i pulumi.IntInput) ResourceClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClassList { return vs[0].([]*ResourceClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceClassListMapOutput) ToResourceClassListMapOutputWithContext(ctx return o } +func (o ResourceClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassList] { + return pulumix.Output[map[string]*ResourceClassList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassListMapOutput) MapIndex(k pulumi.StringInput) ResourceClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClassList { return vs[0].(map[string]*ResourceClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha1/resourceClassPatch.go b/sdk/go/kubernetes/resource/v1alpha1/resourceClassPatch.go index 0a04d4e714..62ae3e7b5b 100644 --- a/sdk/go/kubernetes/resource/v1alpha1/resourceClassPatch.go +++ b/sdk/go/kubernetes/resource/v1alpha1/resourceClassPatch.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -152,6 +153,12 @@ func (i *ResourceClassPatch) ToResourceClassPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchOutput) } +func (i *ResourceClassPatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassPatch] { + return pulumix.Output[*ResourceClassPatch]{ + OutputState: i.ToResourceClassPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClassPatchArrayInput is an input type that accepts ResourceClassPatchArray and ResourceClassPatchArrayOutput values. // You can construct a concrete instance of `ResourceClassPatchArrayInput` via: // @@ -177,6 +184,12 @@ func (i ResourceClassPatchArray) ToResourceClassPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchArrayOutput) } +func (i ResourceClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassPatch] { + return pulumix.Output[[]*ResourceClassPatch]{ + OutputState: i.ToResourceClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClassPatchMapInput is an input type that accepts ResourceClassPatchMap and ResourceClassPatchMapOutput values. // You can construct a concrete instance of `ResourceClassPatchMapInput` via: // @@ -202,6 +215,12 @@ func (i ResourceClassPatchMap) ToResourceClassPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchMapOutput) } +func (i ResourceClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassPatch] { + return pulumix.Output[map[string]*ResourceClassPatch]{ + OutputState: i.ToResourceClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClassPatchOutput struct{ *pulumi.OutputState } func (ResourceClassPatchOutput) ElementType() reflect.Type { @@ -216,6 +235,12 @@ func (o ResourceClassPatchOutput) ToResourceClassPatchOutputWithContext(ctx cont return o } +func (o ResourceClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassPatch] { + return pulumix.Output[*ResourceClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -264,6 +289,12 @@ func (o ResourceClassPatchArrayOutput) ToResourceClassPatchArrayOutputWithContex return o } +func (o ResourceClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassPatch] { + return pulumix.Output[[]*ResourceClassPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassPatchArrayOutput) Index(i pulumi.IntInput) ResourceClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClassPatch { return vs[0].([]*ResourceClassPatch)[vs[1].(int)] @@ -284,6 +315,12 @@ func (o ResourceClassPatchMapOutput) ToResourceClassPatchMapOutputWithContext(ct return o } +func (o ResourceClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassPatch] { + return pulumix.Output[map[string]*ResourceClassPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassPatchMapOutput) MapIndex(k pulumi.StringInput) ResourceClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClassPatch { return vs[0].(map[string]*ResourceClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContext.go b/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContext.go index 61140f10e4..9ce343e25e 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContext.go +++ b/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContext.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSchedulingContext objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode. @@ -121,6 +122,12 @@ func (i *PodSchedulingContext) ToPodSchedulingContextOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextOutput) } +func (i *PodSchedulingContext) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContext] { + return pulumix.Output[*PodSchedulingContext]{ + OutputState: i.ToPodSchedulingContextOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextArrayInput is an input type that accepts PodSchedulingContextArray and PodSchedulingContextArrayOutput values. // You can construct a concrete instance of `PodSchedulingContextArrayInput` via: // @@ -146,6 +153,12 @@ func (i PodSchedulingContextArray) ToPodSchedulingContextArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextArrayOutput) } +func (i PodSchedulingContextArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingContext] { + return pulumix.Output[[]*PodSchedulingContext]{ + OutputState: i.ToPodSchedulingContextArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextMapInput is an input type that accepts PodSchedulingContextMap and PodSchedulingContextMapOutput values. // You can construct a concrete instance of `PodSchedulingContextMapInput` via: // @@ -171,6 +184,12 @@ func (i PodSchedulingContextMap) ToPodSchedulingContextMapOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextMapOutput) } +func (i PodSchedulingContextMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingContext] { + return pulumix.Output[map[string]*PodSchedulingContext]{ + OutputState: i.ToPodSchedulingContextMapOutputWithContext(ctx).OutputState, + } +} + type PodSchedulingContextOutput struct{ *pulumi.OutputState } func (PodSchedulingContextOutput) ElementType() reflect.Type { @@ -185,6 +204,12 @@ func (o PodSchedulingContextOutput) ToPodSchedulingContextOutputWithContext(ctx return o } +func (o PodSchedulingContextOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContext] { + return pulumix.Output[*PodSchedulingContext]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingContextOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSchedulingContext) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -224,6 +249,12 @@ func (o PodSchedulingContextArrayOutput) ToPodSchedulingContextArrayOutputWithCo return o } +func (o PodSchedulingContextArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingContext] { + return pulumix.Output[[]*PodSchedulingContext]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextArrayOutput) Index(i pulumi.IntInput) PodSchedulingContextOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSchedulingContext { return vs[0].([]*PodSchedulingContext)[vs[1].(int)] @@ -244,6 +275,12 @@ func (o PodSchedulingContextMapOutput) ToPodSchedulingContextMapOutputWithContex return o } +func (o PodSchedulingContextMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingContext] { + return pulumix.Output[map[string]*PodSchedulingContext]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextMapOutput) MapIndex(k pulumi.StringInput) PodSchedulingContextOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSchedulingContext { return vs[0].(map[string]*PodSchedulingContext)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextList.go b/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextList.go index fe6006207b..b747263e39 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextList.go +++ b/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodSchedulingContextList is a collection of Pod scheduling objects. @@ -117,6 +118,12 @@ func (i *PodSchedulingContextList) ToPodSchedulingContextListOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextListOutput) } +func (i *PodSchedulingContextList) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextList] { + return pulumix.Output[*PodSchedulingContextList]{ + OutputState: i.ToPodSchedulingContextListOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextListArrayInput is an input type that accepts PodSchedulingContextListArray and PodSchedulingContextListArrayOutput values. // You can construct a concrete instance of `PodSchedulingContextListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodSchedulingContextListArray) ToPodSchedulingContextListArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextListArrayOutput) } +func (i PodSchedulingContextListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingContextList] { + return pulumix.Output[[]*PodSchedulingContextList]{ + OutputState: i.ToPodSchedulingContextListArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextListMapInput is an input type that accepts PodSchedulingContextListMap and PodSchedulingContextListMapOutput values. // You can construct a concrete instance of `PodSchedulingContextListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodSchedulingContextListMap) ToPodSchedulingContextListMapOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextListMapOutput) } +func (i PodSchedulingContextListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingContextList] { + return pulumix.Output[map[string]*PodSchedulingContextList]{ + OutputState: i.ToPodSchedulingContextListMapOutputWithContext(ctx).OutputState, + } +} + type PodSchedulingContextListOutput struct{ *pulumi.OutputState } func (PodSchedulingContextListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodSchedulingContextListOutput) ToPodSchedulingContextListOutputWithCont return o } +func (o PodSchedulingContextListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextList] { + return pulumix.Output[*PodSchedulingContextList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingContextListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodSchedulingContextList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodSchedulingContextListArrayOutput) ToPodSchedulingContextListArrayOutp return o } +func (o PodSchedulingContextListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingContextList] { + return pulumix.Output[[]*PodSchedulingContextList]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextListArrayOutput) Index(i pulumi.IntInput) PodSchedulingContextListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSchedulingContextList { return vs[0].([]*PodSchedulingContextList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodSchedulingContextListMapOutput) ToPodSchedulingContextListMapOutputWi return o } +func (o PodSchedulingContextListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingContextList] { + return pulumix.Output[map[string]*PodSchedulingContextList]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextListMapOutput) MapIndex(k pulumi.StringInput) PodSchedulingContextListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSchedulingContextList { return vs[0].(map[string]*PodSchedulingContextList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextPatch.go b/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextPatch.go index 29e48584b9..5c38ca40f4 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextPatch.go +++ b/sdk/go/kubernetes/resource/v1alpha2/podSchedulingContextPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -123,6 +124,12 @@ func (i *PodSchedulingContextPatch) ToPodSchedulingContextPatchOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextPatchOutput) } +func (i *PodSchedulingContextPatch) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextPatch] { + return pulumix.Output[*PodSchedulingContextPatch]{ + OutputState: i.ToPodSchedulingContextPatchOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextPatchArrayInput is an input type that accepts PodSchedulingContextPatchArray and PodSchedulingContextPatchArrayOutput values. // You can construct a concrete instance of `PodSchedulingContextPatchArrayInput` via: // @@ -148,6 +155,12 @@ func (i PodSchedulingContextPatchArray) ToPodSchedulingContextPatchArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextPatchArrayOutput) } +func (i PodSchedulingContextPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingContextPatch] { + return pulumix.Output[[]*PodSchedulingContextPatch]{ + OutputState: i.ToPodSchedulingContextPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextPatchMapInput is an input type that accepts PodSchedulingContextPatchMap and PodSchedulingContextPatchMapOutput values. // You can construct a concrete instance of `PodSchedulingContextPatchMapInput` via: // @@ -173,6 +186,12 @@ func (i PodSchedulingContextPatchMap) ToPodSchedulingContextPatchMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextPatchMapOutput) } +func (i PodSchedulingContextPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingContextPatch] { + return pulumix.Output[map[string]*PodSchedulingContextPatch]{ + OutputState: i.ToPodSchedulingContextPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodSchedulingContextPatchOutput struct{ *pulumi.OutputState } func (PodSchedulingContextPatchOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o PodSchedulingContextPatchOutput) ToPodSchedulingContextPatchOutputWithCo return o } +func (o PodSchedulingContextPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextPatch] { + return pulumix.Output[*PodSchedulingContextPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingContextPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodSchedulingContextPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -226,6 +251,12 @@ func (o PodSchedulingContextPatchArrayOutput) ToPodSchedulingContextPatchArrayOu return o } +func (o PodSchedulingContextPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodSchedulingContextPatch] { + return pulumix.Output[[]*PodSchedulingContextPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextPatchArrayOutput) Index(i pulumi.IntInput) PodSchedulingContextPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodSchedulingContextPatch { return vs[0].([]*PodSchedulingContextPatch)[vs[1].(int)] @@ -246,6 +277,12 @@ func (o PodSchedulingContextPatchMapOutput) ToPodSchedulingContextPatchMapOutput return o } +func (o PodSchedulingContextPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodSchedulingContextPatch] { + return pulumix.Output[map[string]*PodSchedulingContextPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextPatchMapOutput) MapIndex(k pulumi.StringInput) PodSchedulingContextPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodSchedulingContextPatch { return vs[0].(map[string]*PodSchedulingContextPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/pulumiTypes.go b/sdk/go/kubernetes/resource/v1alpha2/pulumiTypes.go index e912c7918c..5ef9d04846 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/pulumiTypes.go +++ b/sdk/go/kubernetes/resource/v1alpha2/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -66,6 +67,12 @@ func (i AllocationResultArgs) ToAllocationResultOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(AllocationResultOutput) } +func (i AllocationResultArgs) ToOutput(ctx context.Context) pulumix.Output[AllocationResult] { + return pulumix.Output[AllocationResult]{ + OutputState: i.ToAllocationResultOutputWithContext(ctx).OutputState, + } +} + func (i AllocationResultArgs) ToAllocationResultPtrOutput() AllocationResultPtrOutput { return i.ToAllocationResultPtrOutputWithContext(context.Background()) } @@ -107,6 +114,12 @@ func (i *allocationResultPtrType) ToAllocationResultPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(AllocationResultPtrOutput) } +func (i *allocationResultPtrType) ToOutput(ctx context.Context) pulumix.Output[*AllocationResult] { + return pulumix.Output[*AllocationResult]{ + OutputState: i.ToAllocationResultPtrOutputWithContext(ctx).OutputState, + } +} + // AllocationResult contains attributes of an allocated resource. type AllocationResultOutput struct{ *pulumi.OutputState } @@ -132,6 +145,12 @@ func (o AllocationResultOutput) ToAllocationResultPtrOutputWithContext(ctx conte }).(AllocationResultPtrOutput) } +func (o AllocationResultOutput) ToOutput(ctx context.Context) pulumix.Output[AllocationResult] { + return pulumix.Output[AllocationResult]{ + OutputState: o.OutputState, + } +} + // This field will get set by the resource driver after it has allocated the resource to inform the scheduler where it can schedule Pods using the ResourceClaim. // // Setting this field is optional. If null, the resource is available everywhere. @@ -165,6 +184,12 @@ func (o AllocationResultPtrOutput) ToAllocationResultPtrOutputWithContext(ctx co return o } +func (o AllocationResultPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AllocationResult] { + return pulumix.Output[*AllocationResult]{ + OutputState: o.OutputState, + } +} + func (o AllocationResultPtrOutput) Elem() AllocationResultOutput { return o.ApplyT(func(v *AllocationResult) AllocationResult { if v != nil { @@ -260,6 +285,12 @@ func (i AllocationResultPatchArgs) ToAllocationResultPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(AllocationResultPatchOutput) } +func (i AllocationResultPatchArgs) ToOutput(ctx context.Context) pulumix.Output[AllocationResultPatch] { + return pulumix.Output[AllocationResultPatch]{ + OutputState: i.ToAllocationResultPatchOutputWithContext(ctx).OutputState, + } +} + func (i AllocationResultPatchArgs) ToAllocationResultPatchPtrOutput() AllocationResultPatchPtrOutput { return i.ToAllocationResultPatchPtrOutputWithContext(context.Background()) } @@ -301,6 +332,12 @@ func (i *allocationResultPatchPtrType) ToAllocationResultPatchPtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(AllocationResultPatchPtrOutput) } +func (i *allocationResultPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*AllocationResultPatch] { + return pulumix.Output[*AllocationResultPatch]{ + OutputState: i.ToAllocationResultPatchPtrOutputWithContext(ctx).OutputState, + } +} + // AllocationResult contains attributes of an allocated resource. type AllocationResultPatchOutput struct{ *pulumi.OutputState } @@ -326,6 +363,12 @@ func (o AllocationResultPatchOutput) ToAllocationResultPatchPtrOutputWithContext }).(AllocationResultPatchPtrOutput) } +func (o AllocationResultPatchOutput) ToOutput(ctx context.Context) pulumix.Output[AllocationResultPatch] { + return pulumix.Output[AllocationResultPatch]{ + OutputState: o.OutputState, + } +} + // This field will get set by the resource driver after it has allocated the resource to inform the scheduler where it can schedule Pods using the ResourceClaim. // // Setting this field is optional. If null, the resource is available everywhere. @@ -359,6 +402,12 @@ func (o AllocationResultPatchPtrOutput) ToAllocationResultPatchPtrOutputWithCont return o } +func (o AllocationResultPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AllocationResultPatch] { + return pulumix.Output[*AllocationResultPatch]{ + OutputState: o.OutputState, + } +} + func (o AllocationResultPatchPtrOutput) Elem() AllocationResultPatchOutput { return o.ApplyT(func(v *AllocationResultPatch) AllocationResultPatch { if v != nil { @@ -458,6 +507,12 @@ func (i PodSchedulingContextTypeArgs) ToPodSchedulingContextTypeOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextTypeOutput) } +func (i PodSchedulingContextTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextType] { + return pulumix.Output[PodSchedulingContextType]{ + OutputState: i.ToPodSchedulingContextTypeOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextTypeArrayInput is an input type that accepts PodSchedulingContextTypeArray and PodSchedulingContextTypeArrayOutput values. // You can construct a concrete instance of `PodSchedulingContextTypeArrayInput` via: // @@ -483,6 +538,12 @@ func (i PodSchedulingContextTypeArray) ToPodSchedulingContextTypeArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextTypeArrayOutput) } +func (i PodSchedulingContextTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingContextType] { + return pulumix.Output[[]PodSchedulingContextType]{ + OutputState: i.ToPodSchedulingContextTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContext objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -500,6 +561,12 @@ func (o PodSchedulingContextTypeOutput) ToPodSchedulingContextTypeOutputWithCont return o } +func (o PodSchedulingContextTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextType] { + return pulumix.Output[PodSchedulingContextType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingContextTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingContextType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -539,6 +606,12 @@ func (o PodSchedulingContextTypeArrayOutput) ToPodSchedulingContextTypeArrayOutp return o } +func (o PodSchedulingContextTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodSchedulingContextType] { + return pulumix.Output[[]PodSchedulingContextType]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextTypeArrayOutput) Index(i pulumi.IntInput) PodSchedulingContextTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodSchedulingContextType { return vs[0].([]PodSchedulingContextType)[vs[1].(int)] @@ -592,6 +665,12 @@ func (i PodSchedulingContextListTypeArgs) ToPodSchedulingContextListTypeOutputWi return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextListTypeOutput) } +func (i PodSchedulingContextListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextListType] { + return pulumix.Output[PodSchedulingContextListType]{ + OutputState: i.ToPodSchedulingContextListTypeOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextList is a collection of Pod scheduling objects. type PodSchedulingContextListTypeOutput struct{ *pulumi.OutputState } @@ -607,6 +686,12 @@ func (o PodSchedulingContextListTypeOutput) ToPodSchedulingContextListTypeOutput return o } +func (o PodSchedulingContextListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextListType] { + return pulumix.Output[PodSchedulingContextListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingContextListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingContextListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -682,6 +767,12 @@ func (i PodSchedulingContextPatchTypeArgs) ToPodSchedulingContextPatchTypeOutput return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextPatchTypeOutput) } +func (i PodSchedulingContextPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextPatchType] { + return pulumix.Output[PodSchedulingContextPatchType]{ + OutputState: i.ToPodSchedulingContextPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContext objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -699,6 +790,12 @@ func (o PodSchedulingContextPatchTypeOutput) ToPodSchedulingContextPatchTypeOutp return o } +func (o PodSchedulingContextPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextPatchType] { + return pulumix.Output[PodSchedulingContextPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodSchedulingContextPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodSchedulingContextPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -767,6 +864,12 @@ func (i PodSchedulingContextSpecArgs) ToPodSchedulingContextSpecOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextSpecOutput) } +func (i PodSchedulingContextSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextSpec] { + return pulumix.Output[PodSchedulingContextSpec]{ + OutputState: i.ToPodSchedulingContextSpecOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextSpec describes where resources for the Pod are needed. type PodSchedulingContextSpecOutput struct{ *pulumi.OutputState } @@ -782,6 +885,12 @@ func (o PodSchedulingContextSpecOutput) ToPodSchedulingContextSpecOutputWithCont return o } +func (o PodSchedulingContextSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextSpec] { + return pulumix.Output[PodSchedulingContextSpec]{ + OutputState: o.OutputState, + } +} + // PotentialNodes lists nodes where the Pod might be able to run. // // The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced. @@ -837,6 +946,12 @@ func (i PodSchedulingContextSpecPatchArgs) ToPodSchedulingContextSpecPatchOutput return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextSpecPatchOutput) } +func (i PodSchedulingContextSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextSpecPatch] { + return pulumix.Output[PodSchedulingContextSpecPatch]{ + OutputState: i.ToPodSchedulingContextSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSchedulingContextSpecPatchArgs) ToPodSchedulingContextSpecPatchPtrOutput() PodSchedulingContextSpecPatchPtrOutput { return i.ToPodSchedulingContextSpecPatchPtrOutputWithContext(context.Background()) } @@ -878,6 +993,12 @@ func (i *podSchedulingContextSpecPatchPtrType) ToPodSchedulingContextSpecPatchPt return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextSpecPatchPtrOutput) } +func (i *podSchedulingContextSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextSpecPatch] { + return pulumix.Output[*PodSchedulingContextSpecPatch]{ + OutputState: i.ToPodSchedulingContextSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextSpec describes where resources for the Pod are needed. type PodSchedulingContextSpecPatchOutput struct{ *pulumi.OutputState } @@ -903,6 +1024,12 @@ func (o PodSchedulingContextSpecPatchOutput) ToPodSchedulingContextSpecPatchPtrO }).(PodSchedulingContextSpecPatchPtrOutput) } +func (o PodSchedulingContextSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextSpecPatch] { + return pulumix.Output[PodSchedulingContextSpecPatch]{ + OutputState: o.OutputState, + } +} + // PotentialNodes lists nodes where the Pod might be able to run. // // The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced. @@ -929,6 +1056,12 @@ func (o PodSchedulingContextSpecPatchPtrOutput) ToPodSchedulingContextSpecPatchP return o } +func (o PodSchedulingContextSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextSpecPatch] { + return pulumix.Output[*PodSchedulingContextSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextSpecPatchPtrOutput) Elem() PodSchedulingContextSpecPatchOutput { return o.ApplyT(func(v *PodSchedulingContextSpecPatch) PodSchedulingContextSpecPatch { if v != nil { @@ -996,6 +1129,12 @@ func (i PodSchedulingContextStatusArgs) ToPodSchedulingContextStatusOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextStatusOutput) } +func (i PodSchedulingContextStatusArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextStatus] { + return pulumix.Output[PodSchedulingContextStatus]{ + OutputState: i.ToPodSchedulingContextStatusOutputWithContext(ctx).OutputState, + } +} + func (i PodSchedulingContextStatusArgs) ToPodSchedulingContextStatusPtrOutput() PodSchedulingContextStatusPtrOutput { return i.ToPodSchedulingContextStatusPtrOutputWithContext(context.Background()) } @@ -1037,6 +1176,12 @@ func (i *podSchedulingContextStatusPtrType) ToPodSchedulingContextStatusPtrOutpu return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextStatusPtrOutput) } +func (i *podSchedulingContextStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextStatus] { + return pulumix.Output[*PodSchedulingContextStatus]{ + OutputState: i.ToPodSchedulingContextStatusPtrOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextStatus describes where resources for the Pod can be allocated. type PodSchedulingContextStatusOutput struct{ *pulumi.OutputState } @@ -1062,6 +1207,12 @@ func (o PodSchedulingContextStatusOutput) ToPodSchedulingContextStatusPtrOutputW }).(PodSchedulingContextStatusPtrOutput) } +func (o PodSchedulingContextStatusOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextStatus] { + return pulumix.Output[PodSchedulingContextStatus]{ + OutputState: o.OutputState, + } +} + // ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode. func (o PodSchedulingContextStatusOutput) ResourceClaims() ResourceClaimSchedulingStatusArrayOutput { return o.ApplyT(func(v PodSchedulingContextStatus) []ResourceClaimSchedulingStatus { return v.ResourceClaims }).(ResourceClaimSchedulingStatusArrayOutput) @@ -1081,6 +1232,12 @@ func (o PodSchedulingContextStatusPtrOutput) ToPodSchedulingContextStatusPtrOutp return o } +func (o PodSchedulingContextStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextStatus] { + return pulumix.Output[*PodSchedulingContextStatus]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextStatusPtrOutput) Elem() PodSchedulingContextStatusOutput { return o.ApplyT(func(v *PodSchedulingContextStatus) PodSchedulingContextStatus { if v != nil { @@ -1136,6 +1293,12 @@ func (i PodSchedulingContextStatusPatchArgs) ToPodSchedulingContextStatusPatchOu return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextStatusPatchOutput) } +func (i PodSchedulingContextStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextStatusPatch] { + return pulumix.Output[PodSchedulingContextStatusPatch]{ + OutputState: i.ToPodSchedulingContextStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodSchedulingContextStatusPatchArgs) ToPodSchedulingContextStatusPatchPtrOutput() PodSchedulingContextStatusPatchPtrOutput { return i.ToPodSchedulingContextStatusPatchPtrOutputWithContext(context.Background()) } @@ -1177,6 +1340,12 @@ func (i *podSchedulingContextStatusPatchPtrType) ToPodSchedulingContextStatusPat return pulumi.ToOutputWithContext(ctx, i).(PodSchedulingContextStatusPatchPtrOutput) } +func (i *podSchedulingContextStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextStatusPatch] { + return pulumix.Output[*PodSchedulingContextStatusPatch]{ + OutputState: i.ToPodSchedulingContextStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodSchedulingContextStatus describes where resources for the Pod can be allocated. type PodSchedulingContextStatusPatchOutput struct{ *pulumi.OutputState } @@ -1202,6 +1371,12 @@ func (o PodSchedulingContextStatusPatchOutput) ToPodSchedulingContextStatusPatch }).(PodSchedulingContextStatusPatchPtrOutput) } +func (o PodSchedulingContextStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodSchedulingContextStatusPatch] { + return pulumix.Output[PodSchedulingContextStatusPatch]{ + OutputState: o.OutputState, + } +} + // ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode. func (o PodSchedulingContextStatusPatchOutput) ResourceClaims() ResourceClaimSchedulingStatusPatchArrayOutput { return o.ApplyT(func(v PodSchedulingContextStatusPatch) []ResourceClaimSchedulingStatusPatch { return v.ResourceClaims }).(ResourceClaimSchedulingStatusPatchArrayOutput) @@ -1221,6 +1396,12 @@ func (o PodSchedulingContextStatusPatchPtrOutput) ToPodSchedulingContextStatusPa return o } +func (o PodSchedulingContextStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodSchedulingContextStatusPatch] { + return pulumix.Output[*PodSchedulingContextStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o PodSchedulingContextStatusPatchPtrOutput) Elem() PodSchedulingContextStatusPatchOutput { return o.ApplyT(func(v *PodSchedulingContextStatusPatch) PodSchedulingContextStatusPatch { if v != nil { @@ -1296,6 +1477,12 @@ func (i ResourceClaimTypeArgs) ToResourceClaimTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTypeOutput) } +func (i ResourceClaimTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimType] { + return pulumix.Output[ResourceClaimType]{ + OutputState: i.ToResourceClaimTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTypeArrayInput is an input type that accepts ResourceClaimTypeArray and ResourceClaimTypeArrayOutput values. // You can construct a concrete instance of `ResourceClaimTypeArrayInput` via: // @@ -1321,6 +1508,12 @@ func (i ResourceClaimTypeArray) ToResourceClaimTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTypeArrayOutput) } +func (i ResourceClaimTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimType] { + return pulumix.Output[[]ResourceClaimType]{ + OutputState: i.ToResourceClaimTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -1338,6 +1531,12 @@ func (o ResourceClaimTypeOutput) ToResourceClaimTypeOutputWithContext(ctx contex return o } +func (o ResourceClaimTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimType] { + return pulumix.Output[ResourceClaimType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1377,6 +1576,12 @@ func (o ResourceClaimTypeArrayOutput) ToResourceClaimTypeArrayOutputWithContext( return o } +func (o ResourceClaimTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimType] { + return pulumix.Output[[]ResourceClaimType]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTypeArrayOutput) Index(i pulumi.IntInput) ResourceClaimTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimType { return vs[0].([]ResourceClaimType)[vs[1].(int)] @@ -1430,6 +1635,12 @@ func (i ResourceClaimConsumerReferenceArgs) ToResourceClaimConsumerReferenceOutp return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferenceOutput) } +func (i ResourceClaimConsumerReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReference] { + return pulumix.Output[ResourceClaimConsumerReference]{ + OutputState: i.ToResourceClaimConsumerReferenceOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReferenceArrayInput is an input type that accepts ResourceClaimConsumerReferenceArray and ResourceClaimConsumerReferenceArrayOutput values. // You can construct a concrete instance of `ResourceClaimConsumerReferenceArrayInput` via: // @@ -1455,6 +1666,12 @@ func (i ResourceClaimConsumerReferenceArray) ToResourceClaimConsumerReferenceArr return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferenceArrayOutput) } +func (i ResourceClaimConsumerReferenceArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReference] { + return pulumix.Output[[]ResourceClaimConsumerReference]{ + OutputState: i.ToResourceClaimConsumerReferenceArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim. type ResourceClaimConsumerReferenceOutput struct{ *pulumi.OutputState } @@ -1470,6 +1687,12 @@ func (o ResourceClaimConsumerReferenceOutput) ToResourceClaimConsumerReferenceOu return o } +func (o ResourceClaimConsumerReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReference] { + return pulumix.Output[ResourceClaimConsumerReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimConsumerReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimConsumerReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1504,6 +1727,12 @@ func (o ResourceClaimConsumerReferenceArrayOutput) ToResourceClaimConsumerRefere return o } +func (o ResourceClaimConsumerReferenceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReference] { + return pulumix.Output[[]ResourceClaimConsumerReference]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimConsumerReferenceArrayOutput) Index(i pulumi.IntInput) ResourceClaimConsumerReferenceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimConsumerReference { return vs[0].([]ResourceClaimConsumerReference)[vs[1].(int)] @@ -1557,6 +1786,12 @@ func (i ResourceClaimConsumerReferencePatchArgs) ToResourceClaimConsumerReferenc return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferencePatchOutput) } +func (i ResourceClaimConsumerReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReferencePatch] { + return pulumix.Output[ResourceClaimConsumerReferencePatch]{ + OutputState: i.ToResourceClaimConsumerReferencePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReferencePatchArrayInput is an input type that accepts ResourceClaimConsumerReferencePatchArray and ResourceClaimConsumerReferencePatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimConsumerReferencePatchArrayInput` via: // @@ -1582,6 +1817,12 @@ func (i ResourceClaimConsumerReferencePatchArray) ToResourceClaimConsumerReferen return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimConsumerReferencePatchArrayOutput) } +func (i ResourceClaimConsumerReferencePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReferencePatch] { + return pulumix.Output[[]ResourceClaimConsumerReferencePatch]{ + OutputState: i.ToResourceClaimConsumerReferencePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim. type ResourceClaimConsumerReferencePatchOutput struct{ *pulumi.OutputState } @@ -1597,6 +1838,12 @@ func (o ResourceClaimConsumerReferencePatchOutput) ToResourceClaimConsumerRefere return o } +func (o ResourceClaimConsumerReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimConsumerReferencePatch] { + return pulumix.Output[ResourceClaimConsumerReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimConsumerReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimConsumerReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1631,6 +1878,12 @@ func (o ResourceClaimConsumerReferencePatchArrayOutput) ToResourceClaimConsumerR return o } +func (o ResourceClaimConsumerReferencePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimConsumerReferencePatch] { + return pulumix.Output[[]ResourceClaimConsumerReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimConsumerReferencePatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimConsumerReferencePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimConsumerReferencePatch { return vs[0].([]ResourceClaimConsumerReferencePatch)[vs[1].(int)] @@ -1684,6 +1937,12 @@ func (i ResourceClaimListTypeArgs) ToResourceClaimListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListTypeOutput) } +func (i ResourceClaimListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimListType] { + return pulumix.Output[ResourceClaimListType]{ + OutputState: i.ToResourceClaimListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimList is a collection of claims. type ResourceClaimListTypeOutput struct{ *pulumi.OutputState } @@ -1699,6 +1958,12 @@ func (o ResourceClaimListTypeOutput) ToResourceClaimListTypeOutputWithContext(ct return o } +func (o ResourceClaimListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimListType] { + return pulumix.Output[ResourceClaimListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1762,6 +2027,12 @@ func (i ResourceClaimParametersReferenceArgs) ToResourceClaimParametersReference return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferenceOutput) } +func (i ResourceClaimParametersReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReference] { + return pulumix.Output[ResourceClaimParametersReference]{ + OutputState: i.ToResourceClaimParametersReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimParametersReferenceArgs) ToResourceClaimParametersReferencePtrOutput() ResourceClaimParametersReferencePtrOutput { return i.ToResourceClaimParametersReferencePtrOutputWithContext(context.Background()) } @@ -1803,6 +2074,12 @@ func (i *resourceClaimParametersReferencePtrType) ToResourceClaimParametersRefer return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferencePtrOutput) } +func (i *resourceClaimParametersReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReference] { + return pulumix.Output[*ResourceClaimParametersReference]{ + OutputState: i.ToResourceClaimParametersReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim. type ResourceClaimParametersReferenceOutput struct{ *pulumi.OutputState } @@ -1828,6 +2105,12 @@ func (o ResourceClaimParametersReferenceOutput) ToResourceClaimParametersReferen }).(ResourceClaimParametersReferencePtrOutput) } +func (o ResourceClaimParametersReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReference] { + return pulumix.Output[ResourceClaimParametersReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimParametersReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimParametersReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -1857,6 +2140,12 @@ func (o ResourceClaimParametersReferencePtrOutput) ToResourceClaimParametersRefe return o } +func (o ResourceClaimParametersReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReference] { + return pulumix.Output[*ResourceClaimParametersReference]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimParametersReferencePtrOutput) Elem() ResourceClaimParametersReferenceOutput { return o.ApplyT(func(v *ResourceClaimParametersReference) ResourceClaimParametersReference { if v != nil { @@ -1940,6 +2229,12 @@ func (i ResourceClaimParametersReferencePatchArgs) ToResourceClaimParametersRefe return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferencePatchOutput) } +func (i ResourceClaimParametersReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReferencePatch] { + return pulumix.Output[ResourceClaimParametersReferencePatch]{ + OutputState: i.ToResourceClaimParametersReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimParametersReferencePatchArgs) ToResourceClaimParametersReferencePatchPtrOutput() ResourceClaimParametersReferencePatchPtrOutput { return i.ToResourceClaimParametersReferencePatchPtrOutputWithContext(context.Background()) } @@ -1981,6 +2276,12 @@ func (i *resourceClaimParametersReferencePatchPtrType) ToResourceClaimParameters return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimParametersReferencePatchPtrOutput) } +func (i *resourceClaimParametersReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReferencePatch] { + return pulumix.Output[*ResourceClaimParametersReferencePatch]{ + OutputState: i.ToResourceClaimParametersReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim. type ResourceClaimParametersReferencePatchOutput struct{ *pulumi.OutputState } @@ -2006,6 +2307,12 @@ func (o ResourceClaimParametersReferencePatchOutput) ToResourceClaimParametersRe }).(ResourceClaimParametersReferencePatchPtrOutput) } +func (o ResourceClaimParametersReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimParametersReferencePatch] { + return pulumix.Output[ResourceClaimParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClaimParametersReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimParametersReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -2035,6 +2342,12 @@ func (o ResourceClaimParametersReferencePatchPtrOutput) ToResourceClaimParameter return o } +func (o ResourceClaimParametersReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimParametersReferencePatch] { + return pulumix.Output[*ResourceClaimParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimParametersReferencePatchPtrOutput) Elem() ResourceClaimParametersReferencePatchOutput { return o.ApplyT(func(v *ResourceClaimParametersReferencePatch) ResourceClaimParametersReferencePatch { if v != nil { @@ -2130,6 +2443,12 @@ func (i ResourceClaimPatchTypeArgs) ToResourceClaimPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchTypeOutput) } +func (i ResourceClaimPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimPatchType] { + return pulumix.Output[ResourceClaimPatchType]{ + OutputState: i.ToResourceClaimPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -2147,6 +2466,12 @@ func (o ResourceClaimPatchTypeOutput) ToResourceClaimPatchTypeOutputWithContext( return o } +func (o ResourceClaimPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimPatchType] { + return pulumix.Output[ResourceClaimPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2215,6 +2540,12 @@ func (i ResourceClaimSchedulingStatusArgs) ToResourceClaimSchedulingStatusOutput return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusOutput) } +func (i ResourceClaimSchedulingStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatus] { + return pulumix.Output[ResourceClaimSchedulingStatus]{ + OutputState: i.ToResourceClaimSchedulingStatusOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatusArrayInput is an input type that accepts ResourceClaimSchedulingStatusArray and ResourceClaimSchedulingStatusArrayOutput values. // You can construct a concrete instance of `ResourceClaimSchedulingStatusArrayInput` via: // @@ -2240,6 +2571,12 @@ func (i ResourceClaimSchedulingStatusArray) ToResourceClaimSchedulingStatusArray return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusArrayOutput) } +func (i ResourceClaimSchedulingStatusArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatus] { + return pulumix.Output[[]ResourceClaimSchedulingStatus]{ + OutputState: i.ToResourceClaimSchedulingStatusArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode. type ResourceClaimSchedulingStatusOutput struct{ *pulumi.OutputState } @@ -2255,6 +2592,12 @@ func (o ResourceClaimSchedulingStatusOutput) ToResourceClaimSchedulingStatusOutp return o } +func (o ResourceClaimSchedulingStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatus] { + return pulumix.Output[ResourceClaimSchedulingStatus]{ + OutputState: o.OutputState, + } +} + // Name matches the pod.spec.resourceClaims[*].Name field. func (o ResourceClaimSchedulingStatusOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSchedulingStatus) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -2281,6 +2624,12 @@ func (o ResourceClaimSchedulingStatusArrayOutput) ToResourceClaimSchedulingStatu return o } +func (o ResourceClaimSchedulingStatusArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatus] { + return pulumix.Output[[]ResourceClaimSchedulingStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimSchedulingStatusArrayOutput) Index(i pulumi.IntInput) ResourceClaimSchedulingStatusOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimSchedulingStatus { return vs[0].([]ResourceClaimSchedulingStatus)[vs[1].(int)] @@ -2330,6 +2679,12 @@ func (i ResourceClaimSchedulingStatusPatchArgs) ToResourceClaimSchedulingStatusP return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusPatchOutput) } +func (i ResourceClaimSchedulingStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[ResourceClaimSchedulingStatusPatch]{ + OutputState: i.ToResourceClaimSchedulingStatusPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatusPatchArrayInput is an input type that accepts ResourceClaimSchedulingStatusPatchArray and ResourceClaimSchedulingStatusPatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimSchedulingStatusPatchArrayInput` via: // @@ -2355,6 +2710,12 @@ func (i ResourceClaimSchedulingStatusPatchArray) ToResourceClaimSchedulingStatus return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSchedulingStatusPatchArrayOutput) } +func (i ResourceClaimSchedulingStatusPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[[]ResourceClaimSchedulingStatusPatch]{ + OutputState: i.ToResourceClaimSchedulingStatusPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode. type ResourceClaimSchedulingStatusPatchOutput struct{ *pulumi.OutputState } @@ -2370,6 +2731,12 @@ func (o ResourceClaimSchedulingStatusPatchOutput) ToResourceClaimSchedulingStatu return o } +func (o ResourceClaimSchedulingStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[ResourceClaimSchedulingStatusPatch]{ + OutputState: o.OutputState, + } +} + // Name matches the pod.spec.resourceClaims[*].Name field. func (o ResourceClaimSchedulingStatusPatchOutput) Name() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSchedulingStatusPatch) *string { return v.Name }).(pulumi.StringPtrOutput) @@ -2396,6 +2763,12 @@ func (o ResourceClaimSchedulingStatusPatchArrayOutput) ToResourceClaimScheduling return o } +func (o ResourceClaimSchedulingStatusPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimSchedulingStatusPatch] { + return pulumix.Output[[]ResourceClaimSchedulingStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimSchedulingStatusPatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimSchedulingStatusPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimSchedulingStatusPatch { return vs[0].([]ResourceClaimSchedulingStatusPatch)[vs[1].(int)] @@ -2449,6 +2822,12 @@ func (i ResourceClaimSpecArgs) ToResourceClaimSpecOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSpecOutput) } +func (i ResourceClaimSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpec] { + return pulumix.Output[ResourceClaimSpec]{ + OutputState: i.ToResourceClaimSpecOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSpec defines how a resource is to be allocated. type ResourceClaimSpecOutput struct{ *pulumi.OutputState } @@ -2464,6 +2843,12 @@ func (o ResourceClaimSpecOutput) ToResourceClaimSpecOutputWithContext(ctx contex return o } +func (o ResourceClaimSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpec] { + return pulumix.Output[ResourceClaimSpec]{ + OutputState: o.OutputState, + } +} + // Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default. func (o ResourceClaimSpecOutput) AllocationMode() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSpec) *string { return v.AllocationMode }).(pulumi.StringPtrOutput) @@ -2528,6 +2913,12 @@ func (i ResourceClaimSpecPatchArgs) ToResourceClaimSpecPatchOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSpecPatchOutput) } +func (i ResourceClaimSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpecPatch] { + return pulumix.Output[ResourceClaimSpecPatch]{ + OutputState: i.ToResourceClaimSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimSpecPatchArgs) ToResourceClaimSpecPatchPtrOutput() ResourceClaimSpecPatchPtrOutput { return i.ToResourceClaimSpecPatchPtrOutputWithContext(context.Background()) } @@ -2569,6 +2960,12 @@ func (i *resourceClaimSpecPatchPtrType) ToResourceClaimSpecPatchPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimSpecPatchPtrOutput) } +func (i *resourceClaimSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimSpecPatch] { + return pulumix.Output[*ResourceClaimSpecPatch]{ + OutputState: i.ToResourceClaimSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimSpec defines how a resource is to be allocated. type ResourceClaimSpecPatchOutput struct{ *pulumi.OutputState } @@ -2594,6 +2991,12 @@ func (o ResourceClaimSpecPatchOutput) ToResourceClaimSpecPatchPtrOutputWithConte }).(ResourceClaimSpecPatchPtrOutput) } +func (o ResourceClaimSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimSpecPatch] { + return pulumix.Output[ResourceClaimSpecPatch]{ + OutputState: o.OutputState, + } +} + // Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default. func (o ResourceClaimSpecPatchOutput) AllocationMode() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimSpecPatch) *string { return v.AllocationMode }).(pulumi.StringPtrOutput) @@ -2625,6 +3028,12 @@ func (o ResourceClaimSpecPatchPtrOutput) ToResourceClaimSpecPatchPtrOutputWithCo return o } +func (o ResourceClaimSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimSpecPatch] { + return pulumix.Output[*ResourceClaimSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimSpecPatchPtrOutput) Elem() ResourceClaimSpecPatchOutput { return o.ApplyT(func(v *ResourceClaimSpecPatch) ResourceClaimSpecPatch { if v != nil { @@ -2726,6 +3135,12 @@ func (i ResourceClaimStatusArgs) ToResourceClaimStatusOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusOutput) } +func (i ResourceClaimStatusArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatus] { + return pulumix.Output[ResourceClaimStatus]{ + OutputState: i.ToResourceClaimStatusOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimStatusArgs) ToResourceClaimStatusPtrOutput() ResourceClaimStatusPtrOutput { return i.ToResourceClaimStatusPtrOutputWithContext(context.Background()) } @@ -2767,6 +3182,12 @@ func (i *resourceClaimStatusPtrType) ToResourceClaimStatusPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPtrOutput) } +func (i *resourceClaimStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatus] { + return pulumix.Output[*ResourceClaimStatus]{ + OutputState: i.ToResourceClaimStatusPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are. type ResourceClaimStatusOutput struct{ *pulumi.OutputState } @@ -2792,6 +3213,12 @@ func (o ResourceClaimStatusOutput) ToResourceClaimStatusPtrOutputWithContext(ctx }).(ResourceClaimStatusPtrOutput) } +func (o ResourceClaimStatusOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatus] { + return pulumix.Output[ResourceClaimStatus]{ + OutputState: o.OutputState, + } +} + // Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet. func (o ResourceClaimStatusOutput) Allocation() AllocationResultPtrOutput { return o.ApplyT(func(v ResourceClaimStatus) *AllocationResult { return v.Allocation }).(AllocationResultPtrOutput) @@ -2832,6 +3259,12 @@ func (o ResourceClaimStatusPtrOutput) ToResourceClaimStatusPtrOutputWithContext( return o } +func (o ResourceClaimStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatus] { + return pulumix.Output[*ResourceClaimStatus]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimStatusPtrOutput) Elem() ResourceClaimStatusOutput { return o.ApplyT(func(v *ResourceClaimStatus) ResourceClaimStatus { if v != nil { @@ -2947,6 +3380,12 @@ func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchOutput) } +func (i ResourceClaimStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatusPatch] { + return pulumix.Output[ResourceClaimStatusPatch]{ + OutputState: i.ToResourceClaimStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput { return i.ToResourceClaimStatusPatchPtrOutputWithContext(context.Background()) } @@ -2988,6 +3427,12 @@ func (i *resourceClaimStatusPatchPtrType) ToResourceClaimStatusPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchPtrOutput) } +func (i *resourceClaimStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatusPatch] { + return pulumix.Output[*ResourceClaimStatusPatch]{ + OutputState: i.ToResourceClaimStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are. type ResourceClaimStatusPatchOutput struct{ *pulumi.OutputState } @@ -3013,6 +3458,12 @@ func (o ResourceClaimStatusPatchOutput) ToResourceClaimStatusPatchPtrOutputWithC }).(ResourceClaimStatusPatchPtrOutput) } +func (o ResourceClaimStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimStatusPatch] { + return pulumix.Output[ResourceClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + // Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet. func (o ResourceClaimStatusPatchOutput) Allocation() AllocationResultPatchPtrOutput { return o.ApplyT(func(v ResourceClaimStatusPatch) *AllocationResultPatch { return v.Allocation }).(AllocationResultPatchPtrOutput) @@ -3053,6 +3504,12 @@ func (o ResourceClaimStatusPatchPtrOutput) ToResourceClaimStatusPatchPtrOutputWi return o } +func (o ResourceClaimStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimStatusPatch] { + return pulumix.Output[*ResourceClaimStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimStatusPatchPtrOutput) Elem() ResourceClaimStatusPatchOutput { return o.ApplyT(func(v *ResourceClaimStatusPatch) ResourceClaimStatusPatch { if v != nil { @@ -3160,6 +3617,12 @@ func (i ResourceClaimTemplateTypeArgs) ToResourceClaimTemplateTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateTypeOutput) } +func (i ResourceClaimTemplateTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateType] { + return pulumix.Output[ResourceClaimTemplateType]{ + OutputState: i.ToResourceClaimTemplateTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateTypeArrayInput is an input type that accepts ResourceClaimTemplateTypeArray and ResourceClaimTemplateTypeArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplateTypeArrayInput` via: // @@ -3185,6 +3648,12 @@ func (i ResourceClaimTemplateTypeArray) ToResourceClaimTemplateTypeArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateTypeArrayOutput) } +func (i ResourceClaimTemplateTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimTemplateType] { + return pulumix.Output[[]ResourceClaimTemplateType]{ + OutputState: i.ToResourceClaimTemplateTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplate is used to produce ResourceClaim objects. type ResourceClaimTemplateTypeOutput struct{ *pulumi.OutputState } @@ -3200,6 +3669,12 @@ func (o ResourceClaimTemplateTypeOutput) ToResourceClaimTemplateTypeOutputWithCo return o } +func (o ResourceClaimTemplateTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateType] { + return pulumix.Output[ResourceClaimTemplateType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3236,6 +3711,12 @@ func (o ResourceClaimTemplateTypeArrayOutput) ToResourceClaimTemplateTypeArrayOu return o } +func (o ResourceClaimTemplateTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClaimTemplateType] { + return pulumix.Output[[]ResourceClaimTemplateType]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateTypeArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimTemplateType { return vs[0].([]ResourceClaimTemplateType)[vs[1].(int)] @@ -3289,6 +3770,12 @@ func (i ResourceClaimTemplateListTypeArgs) ToResourceClaimTemplateListTypeOutput return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListTypeOutput) } +func (i ResourceClaimTemplateListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateListType] { + return pulumix.Output[ResourceClaimTemplateListType]{ + OutputState: i.ToResourceClaimTemplateListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateList is a collection of claim templates. type ResourceClaimTemplateListTypeOutput struct{ *pulumi.OutputState } @@ -3304,6 +3791,12 @@ func (o ResourceClaimTemplateListTypeOutput) ToResourceClaimTemplateListTypeOutp return o } +func (o ResourceClaimTemplateListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateListType] { + return pulumix.Output[ResourceClaimTemplateListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3375,6 +3868,12 @@ func (i ResourceClaimTemplatePatchTypeArgs) ToResourceClaimTemplatePatchTypeOutp return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchTypeOutput) } +func (i ResourceClaimTemplatePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplatePatchType] { + return pulumix.Output[ResourceClaimTemplatePatchType]{ + OutputState: i.ToResourceClaimTemplatePatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplate is used to produce ResourceClaim objects. type ResourceClaimTemplatePatchTypeOutput struct{ *pulumi.OutputState } @@ -3390,6 +3889,12 @@ func (o ResourceClaimTemplatePatchTypeOutput) ToResourceClaimTemplatePatchTypeOu return o } +func (o ResourceClaimTemplatePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplatePatchType] { + return pulumix.Output[ResourceClaimTemplatePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplatePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClaimTemplatePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3451,6 +3956,12 @@ func (i ResourceClaimTemplateSpecArgs) ToResourceClaimTemplateSpecOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecOutput) } +func (i ResourceClaimTemplateSpecArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpec] { + return pulumix.Output[ResourceClaimTemplateSpec]{ + OutputState: i.ToResourceClaimTemplateSpecOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim. type ResourceClaimTemplateSpecOutput struct{ *pulumi.OutputState } @@ -3466,6 +3977,12 @@ func (o ResourceClaimTemplateSpecOutput) ToResourceClaimTemplateSpecOutputWithCo return o } +func (o ResourceClaimTemplateSpecOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpec] { + return pulumix.Output[ResourceClaimTemplateSpec]{ + OutputState: o.OutputState, + } +} + // ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. func (o ResourceClaimTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) @@ -3515,6 +4032,12 @@ func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchOutp return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchOutput) } +func (i ResourceClaimTemplateSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpecPatch] { + return pulumix.Output[ResourceClaimTemplateSpecPatch]{ + OutputState: i.ToResourceClaimTemplateSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput { return i.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(context.Background()) } @@ -3556,6 +4079,12 @@ func (i *resourceClaimTemplateSpecPatchPtrType) ToResourceClaimTemplateSpecPatch return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchPtrOutput) } +func (i *resourceClaimTemplateSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateSpecPatch] { + return pulumix.Output[*ResourceClaimTemplateSpecPatch]{ + OutputState: i.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim. type ResourceClaimTemplateSpecPatchOutput struct{ *pulumi.OutputState } @@ -3581,6 +4110,12 @@ func (o ResourceClaimTemplateSpecPatchOutput) ToResourceClaimTemplateSpecPatchPt }).(ResourceClaimTemplateSpecPatchPtrOutput) } +func (o ResourceClaimTemplateSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClaimTemplateSpecPatch] { + return pulumix.Output[ResourceClaimTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + // ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. func (o ResourceClaimTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { return o.ApplyT(func(v ResourceClaimTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) @@ -3605,6 +4140,12 @@ func (o ResourceClaimTemplateSpecPatchPtrOutput) ToResourceClaimTemplateSpecPatc return o } +func (o ResourceClaimTemplateSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateSpecPatch] { + return pulumix.Output[*ResourceClaimTemplateSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateSpecPatchPtrOutput) Elem() ResourceClaimTemplateSpecPatchOutput { return o.ApplyT(func(v *ResourceClaimTemplateSpecPatch) ResourceClaimTemplateSpecPatch { if v != nil { @@ -3702,6 +4243,12 @@ func (i ResourceClassTypeArgs) ToResourceClassTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceClassTypeOutput) } +func (i ResourceClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassType] { + return pulumix.Output[ResourceClassType]{ + OutputState: i.ToResourceClassTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClassTypeArrayInput is an input type that accepts ResourceClassTypeArray and ResourceClassTypeArrayOutput values. // You can construct a concrete instance of `ResourceClassTypeArrayInput` via: // @@ -3727,6 +4274,12 @@ func (i ResourceClassTypeArray) ToResourceClassTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClassTypeArrayOutput) } +func (i ResourceClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClassType] { + return pulumix.Output[[]ResourceClassType]{ + OutputState: i.ToResourceClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClass is used by administrators to influence how resources are allocated. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -3744,6 +4297,12 @@ func (o ResourceClassTypeOutput) ToResourceClassTypeOutputWithContext(ctx contex return o } +func (o ResourceClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassType] { + return pulumix.Output[ResourceClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3792,6 +4351,12 @@ func (o ResourceClassTypeArrayOutput) ToResourceClassTypeArrayOutputWithContext( return o } +func (o ResourceClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceClassType] { + return pulumix.Output[[]ResourceClassType]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassTypeArrayOutput) Index(i pulumi.IntInput) ResourceClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClassType { return vs[0].([]ResourceClassType)[vs[1].(int)] @@ -3845,6 +4410,12 @@ func (i ResourceClassListTypeArgs) ToResourceClassListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListTypeOutput) } +func (i ResourceClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassListType] { + return pulumix.Output[ResourceClassListType]{ + OutputState: i.ToResourceClassListTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClassList is a collection of classes. type ResourceClassListTypeOutput struct{ *pulumi.OutputState } @@ -3860,6 +4431,12 @@ func (o ResourceClassListTypeOutput) ToResourceClassListTypeOutputWithContext(ct return o } +func (o ResourceClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassListType] { + return pulumix.Output[ResourceClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3927,6 +4504,12 @@ func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReference return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferenceOutput) } +func (i ResourceClassParametersReferenceArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReference] { + return pulumix.Output[ResourceClassParametersReference]{ + OutputState: i.ToResourceClassParametersReferenceOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput { return i.ToResourceClassParametersReferencePtrOutputWithContext(context.Background()) } @@ -3968,6 +4551,12 @@ func (i *resourceClassParametersReferencePtrType) ToResourceClassParametersRefer return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePtrOutput) } +func (i *resourceClassParametersReferencePtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReference] { + return pulumix.Output[*ResourceClassParametersReference]{ + OutputState: i.ToResourceClassParametersReferencePtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass. type ResourceClassParametersReferenceOutput struct{ *pulumi.OutputState } @@ -3993,6 +4582,12 @@ func (o ResourceClassParametersReferenceOutput) ToResourceClassParametersReferen }).(ResourceClassParametersReferencePtrOutput) } +func (o ResourceClassParametersReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReference] { + return pulumix.Output[ResourceClassParametersReference]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClassParametersReferenceOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassParametersReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -4027,6 +4622,12 @@ func (o ResourceClassParametersReferencePtrOutput) ToResourceClassParametersRefe return o } +func (o ResourceClassParametersReferencePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReference] { + return pulumix.Output[*ResourceClassParametersReference]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassParametersReferencePtrOutput) Elem() ResourceClassParametersReferenceOutput { return o.ApplyT(func(v *ResourceClassParametersReference) ResourceClassParametersReference { if v != nil { @@ -4124,6 +4725,12 @@ func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersRefe return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchOutput) } +func (i ResourceClassParametersReferencePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReferencePatch] { + return pulumix.Output[ResourceClassParametersReferencePatch]{ + OutputState: i.ToResourceClassParametersReferencePatchOutputWithContext(ctx).OutputState, + } +} + func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput { return i.ToResourceClassParametersReferencePatchPtrOutputWithContext(context.Background()) } @@ -4165,6 +4772,12 @@ func (i *resourceClassParametersReferencePatchPtrType) ToResourceClassParameters return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchPtrOutput) } +func (i *resourceClassParametersReferencePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReferencePatch] { + return pulumix.Output[*ResourceClassParametersReferencePatch]{ + OutputState: i.ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx).OutputState, + } +} + // ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass. type ResourceClassParametersReferencePatchOutput struct{ *pulumi.OutputState } @@ -4190,6 +4803,12 @@ func (o ResourceClassParametersReferencePatchOutput) ToResourceClassParametersRe }).(ResourceClassParametersReferencePatchPtrOutput) } +func (o ResourceClassParametersReferencePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassParametersReferencePatch] { + return pulumix.Output[ResourceClassParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + // APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources. func (o ResourceClassParametersReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassParametersReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput) @@ -4224,6 +4843,12 @@ func (o ResourceClassParametersReferencePatchPtrOutput) ToResourceClassParameter return o } +func (o ResourceClassParametersReferencePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassParametersReferencePatch] { + return pulumix.Output[*ResourceClassParametersReferencePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassParametersReferencePatchPtrOutput) Elem() ResourceClassParametersReferencePatchOutput { return o.ApplyT(func(v *ResourceClassParametersReferencePatch) ResourceClassParametersReferencePatch { if v != nil { @@ -4341,6 +4966,12 @@ func (i ResourceClassPatchTypeArgs) ToResourceClassPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchTypeOutput) } +func (i ResourceClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceClassPatchType] { + return pulumix.Output[ResourceClassPatchType]{ + OutputState: i.ToResourceClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // ResourceClass is used by administrators to influence how resources are allocated. // // This is an alpha type and requires enabling the DynamicResourceAllocation feature gate. @@ -4358,6 +4989,12 @@ func (o ResourceClassPatchTypeOutput) ToResourceClassPatchTypeOutputWithContext( return o } +func (o ResourceClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceClassPatchType] { + return pulumix.Output[ResourceClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v ResourceClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -4435,6 +5072,12 @@ func (i ResourceHandleArgs) ToResourceHandleOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ResourceHandleOutput) } +func (i ResourceHandleArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceHandle] { + return pulumix.Output[ResourceHandle]{ + OutputState: i.ToResourceHandleOutputWithContext(ctx).OutputState, + } +} + // ResourceHandleArrayInput is an input type that accepts ResourceHandleArray and ResourceHandleArrayOutput values. // You can construct a concrete instance of `ResourceHandleArrayInput` via: // @@ -4460,6 +5103,12 @@ func (i ResourceHandleArray) ToResourceHandleArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ResourceHandleArrayOutput) } +func (i ResourceHandleArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceHandle] { + return pulumix.Output[[]ResourceHandle]{ + OutputState: i.ToResourceHandleArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceHandle holds opaque resource data for processing by a specific kubelet plugin. type ResourceHandleOutput struct{ *pulumi.OutputState } @@ -4475,6 +5124,12 @@ func (o ResourceHandleOutput) ToResourceHandleOutputWithContext(ctx context.Cont return o } +func (o ResourceHandleOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceHandle] { + return pulumix.Output[ResourceHandle]{ + OutputState: o.OutputState, + } +} + // Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle. // // The maximum size of this field is 16KiB. This may get increased in the future, but not reduced. @@ -4501,6 +5156,12 @@ func (o ResourceHandleArrayOutput) ToResourceHandleArrayOutputWithContext(ctx co return o } +func (o ResourceHandleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceHandle] { + return pulumix.Output[[]ResourceHandle]{ + OutputState: o.OutputState, + } +} + func (o ResourceHandleArrayOutput) Index(i pulumi.IntInput) ResourceHandleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceHandle { return vs[0].([]ResourceHandle)[vs[1].(int)] @@ -4550,6 +5211,12 @@ func (i ResourceHandlePatchArgs) ToResourceHandlePatchOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceHandlePatchOutput) } +func (i ResourceHandlePatchArgs) ToOutput(ctx context.Context) pulumix.Output[ResourceHandlePatch] { + return pulumix.Output[ResourceHandlePatch]{ + OutputState: i.ToResourceHandlePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceHandlePatchArrayInput is an input type that accepts ResourceHandlePatchArray and ResourceHandlePatchArrayOutput values. // You can construct a concrete instance of `ResourceHandlePatchArrayInput` via: // @@ -4575,6 +5242,12 @@ func (i ResourceHandlePatchArray) ToResourceHandlePatchArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceHandlePatchArrayOutput) } +func (i ResourceHandlePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]ResourceHandlePatch] { + return pulumix.Output[[]ResourceHandlePatch]{ + OutputState: i.ToResourceHandlePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceHandle holds opaque resource data for processing by a specific kubelet plugin. type ResourceHandlePatchOutput struct{ *pulumi.OutputState } @@ -4590,6 +5263,12 @@ func (o ResourceHandlePatchOutput) ToResourceHandlePatchOutputWithContext(ctx co return o } +func (o ResourceHandlePatchOutput) ToOutput(ctx context.Context) pulumix.Output[ResourceHandlePatch] { + return pulumix.Output[ResourceHandlePatch]{ + OutputState: o.OutputState, + } +} + // Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle. // // The maximum size of this field is 16KiB. This may get increased in the future, but not reduced. @@ -4616,6 +5295,12 @@ func (o ResourceHandlePatchArrayOutput) ToResourceHandlePatchArrayOutputWithCont return o } +func (o ResourceHandlePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResourceHandlePatch] { + return pulumix.Output[[]ResourceHandlePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceHandlePatchArrayOutput) Index(i pulumi.IntInput) ResourceHandlePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceHandlePatch { return vs[0].([]ResourceHandlePatch)[vs[1].(int)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClaim.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClaim.go index 9216f67525..b693014a0d 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClaim.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClaim.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are. @@ -127,6 +128,12 @@ func (i *ResourceClaim) ToResourceClaimOutputWithContext(ctx context.Context) Re return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimOutput) } +func (i *ResourceClaim) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaim] { + return pulumix.Output[*ResourceClaim]{ + OutputState: i.ToResourceClaimOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimArrayInput is an input type that accepts ResourceClaimArray and ResourceClaimArrayOutput values. // You can construct a concrete instance of `ResourceClaimArrayInput` via: // @@ -152,6 +159,12 @@ func (i ResourceClaimArray) ToResourceClaimArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimArrayOutput) } +func (i ResourceClaimArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaim] { + return pulumix.Output[[]*ResourceClaim]{ + OutputState: i.ToResourceClaimArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimMapInput is an input type that accepts ResourceClaimMap and ResourceClaimMapOutput values. // You can construct a concrete instance of `ResourceClaimMapInput` via: // @@ -177,6 +190,12 @@ func (i ResourceClaimMap) ToResourceClaimMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimMapOutput) } +func (i ResourceClaimMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaim] { + return pulumix.Output[map[string]*ResourceClaim]{ + OutputState: i.ToResourceClaimMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimOutput struct{ *pulumi.OutputState } func (ResourceClaimOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o ResourceClaimOutput) ToResourceClaimOutputWithContext(ctx context.Contex return o } +func (o ResourceClaimOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaim] { + return pulumix.Output[*ResourceClaim]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaim) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -230,6 +255,12 @@ func (o ResourceClaimArrayOutput) ToResourceClaimArrayOutputWithContext(ctx cont return o } +func (o ResourceClaimArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaim] { + return pulumix.Output[[]*ResourceClaim]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimArrayOutput) Index(i pulumi.IntInput) ResourceClaimOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaim { return vs[0].([]*ResourceClaim)[vs[1].(int)] @@ -250,6 +281,12 @@ func (o ResourceClaimMapOutput) ToResourceClaimMapOutputWithContext(ctx context. return o } +func (o ResourceClaimMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaim] { + return pulumix.Output[map[string]*ResourceClaim]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaim { return vs[0].(map[string]*ResourceClaim)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimList.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimList.go index 5460847b14..2c99e241ca 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimList.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaimList is a collection of claims. @@ -117,6 +118,12 @@ func (i *ResourceClaimList) ToResourceClaimListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListOutput) } +func (i *ResourceClaimList) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimList] { + return pulumix.Output[*ResourceClaimList]{ + OutputState: i.ToResourceClaimListOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimListArrayInput is an input type that accepts ResourceClaimListArray and ResourceClaimListArrayOutput values. // You can construct a concrete instance of `ResourceClaimListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceClaimListArray) ToResourceClaimListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListArrayOutput) } +func (i ResourceClaimListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimList] { + return pulumix.Output[[]*ResourceClaimList]{ + OutputState: i.ToResourceClaimListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimListMapInput is an input type that accepts ResourceClaimListMap and ResourceClaimListMapOutput values. // You can construct a concrete instance of `ResourceClaimListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceClaimListMap) ToResourceClaimListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimListMapOutput) } +func (i ResourceClaimListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimList] { + return pulumix.Output[map[string]*ResourceClaimList]{ + OutputState: i.ToResourceClaimListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimListOutput struct{ *pulumi.OutputState } func (ResourceClaimListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceClaimListOutput) ToResourceClaimListOutputWithContext(ctx contex return o } +func (o ResourceClaimListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimList] { + return pulumix.Output[*ResourceClaimList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaimList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceClaimListArrayOutput) ToResourceClaimListArrayOutputWithContext( return o } +func (o ResourceClaimListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimList] { + return pulumix.Output[[]*ResourceClaimList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimListArrayOutput) Index(i pulumi.IntInput) ResourceClaimListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimList { return vs[0].([]*ResourceClaimList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceClaimListMapOutput) ToResourceClaimListMapOutputWithContext(ctx return o } +func (o ResourceClaimListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimList] { + return pulumix.Output[map[string]*ResourceClaimList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimListMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimList { return vs[0].(map[string]*ResourceClaimList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimPatch.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimPatch.go index 5d9f7607be..808baeb563 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimPatch.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -129,6 +130,12 @@ func (i *ResourceClaimPatch) ToResourceClaimPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchOutput) } +func (i *ResourceClaimPatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimPatch] { + return pulumix.Output[*ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimPatchArrayInput is an input type that accepts ResourceClaimPatchArray and ResourceClaimPatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimPatchArrayInput` via: // @@ -154,6 +161,12 @@ func (i ResourceClaimPatchArray) ToResourceClaimPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchArrayOutput) } +func (i ResourceClaimPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimPatch] { + return pulumix.Output[[]*ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimPatchMapInput is an input type that accepts ResourceClaimPatchMap and ResourceClaimPatchMapOutput values. // You can construct a concrete instance of `ResourceClaimPatchMapInput` via: // @@ -179,6 +192,12 @@ func (i ResourceClaimPatchMap) ToResourceClaimPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimPatchMapOutput) } +func (i ResourceClaimPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimPatch] { + return pulumix.Output[map[string]*ResourceClaimPatch]{ + OutputState: i.ToResourceClaimPatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimPatchOutput struct{ *pulumi.OutputState } func (ResourceClaimPatchOutput) ElementType() reflect.Type { @@ -193,6 +212,12 @@ func (o ResourceClaimPatchOutput) ToResourceClaimPatchOutputWithContext(ctx cont return o } +func (o ResourceClaimPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimPatch] { + return pulumix.Output[*ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceClaimPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -232,6 +257,12 @@ func (o ResourceClaimPatchArrayOutput) ToResourceClaimPatchArrayOutputWithContex return o } +func (o ResourceClaimPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimPatch] { + return pulumix.Output[[]*ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimPatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimPatch { return vs[0].([]*ResourceClaimPatch)[vs[1].(int)] @@ -252,6 +283,12 @@ func (o ResourceClaimPatchMapOutput) ToResourceClaimPatchMapOutputWithContext(ct return o } +func (o ResourceClaimPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimPatch] { + return pulumix.Output[map[string]*ResourceClaimPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimPatchMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimPatch { return vs[0].(map[string]*ResourceClaimPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplate.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplate.go index a0d6103ff0..0cea15a630 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplate.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplate.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaimTemplate is used to produce ResourceClaim objects. @@ -129,6 +130,12 @@ func (i *ResourceClaimTemplate) ToResourceClaimTemplateOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateOutput) } +func (i *ResourceClaimTemplate) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplate] { + return pulumix.Output[*ResourceClaimTemplate]{ + OutputState: i.ToResourceClaimTemplateOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateArrayInput is an input type that accepts ResourceClaimTemplateArray and ResourceClaimTemplateArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplateArrayInput` via: // @@ -154,6 +161,12 @@ func (i ResourceClaimTemplateArray) ToResourceClaimTemplateArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateArrayOutput) } +func (i ResourceClaimTemplateArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplate] { + return pulumix.Output[[]*ResourceClaimTemplate]{ + OutputState: i.ToResourceClaimTemplateArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateMapInput is an input type that accepts ResourceClaimTemplateMap and ResourceClaimTemplateMapOutput values. // You can construct a concrete instance of `ResourceClaimTemplateMapInput` via: // @@ -179,6 +192,12 @@ func (i ResourceClaimTemplateMap) ToResourceClaimTemplateMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateMapOutput) } +func (i ResourceClaimTemplateMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplate] { + return pulumix.Output[map[string]*ResourceClaimTemplate]{ + OutputState: i.ToResourceClaimTemplateMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimTemplateOutput struct{ *pulumi.OutputState } func (ResourceClaimTemplateOutput) ElementType() reflect.Type { @@ -193,6 +212,12 @@ func (o ResourceClaimTemplateOutput) ToResourceClaimTemplateOutputWithContext(ct return o } +func (o ResourceClaimTemplateOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplate] { + return pulumix.Output[*ResourceClaimTemplate]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaimTemplate) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -229,6 +254,12 @@ func (o ResourceClaimTemplateArrayOutput) ToResourceClaimTemplateArrayOutputWith return o } +func (o ResourceClaimTemplateArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplate] { + return pulumix.Output[[]*ResourceClaimTemplate]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimTemplate { return vs[0].([]*ResourceClaimTemplate)[vs[1].(int)] @@ -249,6 +280,12 @@ func (o ResourceClaimTemplateMapOutput) ToResourceClaimTemplateMapOutputWithCont return o } +func (o ResourceClaimTemplateMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplate] { + return pulumix.Output[map[string]*ResourceClaimTemplate]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimTemplateOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimTemplate { return vs[0].(map[string]*ResourceClaimTemplate)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplateList.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplateList.go index b73eb3ad5f..159cc9e681 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplateList.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplateList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClaimTemplateList is a collection of claim templates. @@ -117,6 +118,12 @@ func (i *ResourceClaimTemplateList) ToResourceClaimTemplateListOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListOutput) } +func (i *ResourceClaimTemplateList) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateList] { + return pulumix.Output[*ResourceClaimTemplateList]{ + OutputState: i.ToResourceClaimTemplateListOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateListArrayInput is an input type that accepts ResourceClaimTemplateListArray and ResourceClaimTemplateListArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplateListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceClaimTemplateListArray) ToResourceClaimTemplateListArrayOutputWi return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListArrayOutput) } +func (i ResourceClaimTemplateListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplateList] { + return pulumix.Output[[]*ResourceClaimTemplateList]{ + OutputState: i.ToResourceClaimTemplateListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplateListMapInput is an input type that accepts ResourceClaimTemplateListMap and ResourceClaimTemplateListMapOutput values. // You can construct a concrete instance of `ResourceClaimTemplateListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceClaimTemplateListMap) ToResourceClaimTemplateListMapOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListMapOutput) } +func (i ResourceClaimTemplateListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplateList] { + return pulumix.Output[map[string]*ResourceClaimTemplateList]{ + OutputState: i.ToResourceClaimTemplateListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimTemplateListOutput struct{ *pulumi.OutputState } func (ResourceClaimTemplateListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceClaimTemplateListOutput) ToResourceClaimTemplateListOutputWithCo return o } +func (o ResourceClaimTemplateListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplateList] { + return pulumix.Output[*ResourceClaimTemplateList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplateListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClaimTemplateList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceClaimTemplateListArrayOutput) ToResourceClaimTemplateListArrayOu return o } +func (o ResourceClaimTemplateListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplateList] { + return pulumix.Output[[]*ResourceClaimTemplateList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateListArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimTemplateList { return vs[0].([]*ResourceClaimTemplateList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceClaimTemplateListMapOutput) ToResourceClaimTemplateListMapOutput return o } +func (o ResourceClaimTemplateListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplateList] { + return pulumix.Output[map[string]*ResourceClaimTemplateList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplateListMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimTemplateListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimTemplateList { return vs[0].(map[string]*ResourceClaimTemplateList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplatePatch.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplatePatch.go index f8437c11cc..4fa8e600f2 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplatePatch.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClaimTemplatePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -131,6 +132,12 @@ func (i *ResourceClaimTemplatePatch) ToResourceClaimTemplatePatchOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchOutput) } +func (i *ResourceClaimTemplatePatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplatePatch] { + return pulumix.Output[*ResourceClaimTemplatePatch]{ + OutputState: i.ToResourceClaimTemplatePatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplatePatchArrayInput is an input type that accepts ResourceClaimTemplatePatchArray and ResourceClaimTemplatePatchArrayOutput values. // You can construct a concrete instance of `ResourceClaimTemplatePatchArrayInput` via: // @@ -156,6 +163,12 @@ func (i ResourceClaimTemplatePatchArray) ToResourceClaimTemplatePatchArrayOutput return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchArrayOutput) } +func (i ResourceClaimTemplatePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplatePatch] { + return pulumix.Output[[]*ResourceClaimTemplatePatch]{ + OutputState: i.ToResourceClaimTemplatePatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClaimTemplatePatchMapInput is an input type that accepts ResourceClaimTemplatePatchMap and ResourceClaimTemplatePatchMapOutput values. // You can construct a concrete instance of `ResourceClaimTemplatePatchMapInput` via: // @@ -181,6 +194,12 @@ func (i ResourceClaimTemplatePatchMap) ToResourceClaimTemplatePatchMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchMapOutput) } +func (i ResourceClaimTemplatePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplatePatch] { + return pulumix.Output[map[string]*ResourceClaimTemplatePatch]{ + OutputState: i.ToResourceClaimTemplatePatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClaimTemplatePatchOutput struct{ *pulumi.OutputState } func (ResourceClaimTemplatePatchOutput) ElementType() reflect.Type { @@ -195,6 +214,12 @@ func (o ResourceClaimTemplatePatchOutput) ToResourceClaimTemplatePatchOutputWith return o } +func (o ResourceClaimTemplatePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClaimTemplatePatch] { + return pulumix.Output[*ResourceClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClaimTemplatePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceClaimTemplatePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -231,6 +256,12 @@ func (o ResourceClaimTemplatePatchArrayOutput) ToResourceClaimTemplatePatchArray return o } +func (o ResourceClaimTemplatePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClaimTemplatePatch] { + return pulumix.Output[[]*ResourceClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplatePatchArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplatePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClaimTemplatePatch { return vs[0].([]*ResourceClaimTemplatePatch)[vs[1].(int)] @@ -251,6 +282,12 @@ func (o ResourceClaimTemplatePatchMapOutput) ToResourceClaimTemplatePatchMapOutp return o } +func (o ResourceClaimTemplatePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClaimTemplatePatch] { + return pulumix.Output[map[string]*ResourceClaimTemplatePatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClaimTemplatePatchMapOutput) MapIndex(k pulumi.StringInput) ResourceClaimTemplatePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClaimTemplatePatch { return vs[0].(map[string]*ResourceClaimTemplatePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClass.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClass.go index e16e6461fb..9d9f8aeba7 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClass.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClass.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClass is used by administrators to influence how resources are allocated. @@ -150,6 +151,12 @@ func (i *ResourceClass) ToResourceClassOutputWithContext(ctx context.Context) Re return pulumi.ToOutputWithContext(ctx, i).(ResourceClassOutput) } +func (i *ResourceClass) ToOutput(ctx context.Context) pulumix.Output[*ResourceClass] { + return pulumix.Output[*ResourceClass]{ + OutputState: i.ToResourceClassOutputWithContext(ctx).OutputState, + } +} + // ResourceClassArrayInput is an input type that accepts ResourceClassArray and ResourceClassArrayOutput values. // You can construct a concrete instance of `ResourceClassArrayInput` via: // @@ -175,6 +182,12 @@ func (i ResourceClassArray) ToResourceClassArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(ResourceClassArrayOutput) } +func (i ResourceClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClass] { + return pulumix.Output[[]*ResourceClass]{ + OutputState: i.ToResourceClassArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClassMapInput is an input type that accepts ResourceClassMap and ResourceClassMapOutput values. // You can construct a concrete instance of `ResourceClassMapInput` via: // @@ -200,6 +213,12 @@ func (i ResourceClassMap) ToResourceClassMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClassMapOutput) } +func (i ResourceClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClass] { + return pulumix.Output[map[string]*ResourceClass]{ + OutputState: i.ToResourceClassMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClassOutput struct{ *pulumi.OutputState } func (ResourceClassOutput) ElementType() reflect.Type { @@ -214,6 +233,12 @@ func (o ResourceClassOutput) ToResourceClassOutputWithContext(ctx context.Contex return o } +func (o ResourceClassOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClass] { + return pulumix.Output[*ResourceClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -262,6 +287,12 @@ func (o ResourceClassArrayOutput) ToResourceClassArrayOutputWithContext(ctx cont return o } +func (o ResourceClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClass] { + return pulumix.Output[[]*ResourceClass]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassArrayOutput) Index(i pulumi.IntInput) ResourceClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClass { return vs[0].([]*ResourceClass)[vs[1].(int)] @@ -282,6 +313,12 @@ func (o ResourceClassMapOutput) ToResourceClassMapOutputWithContext(ctx context. return o } +func (o ResourceClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClass] { + return pulumix.Output[map[string]*ResourceClass]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassMapOutput) MapIndex(k pulumi.StringInput) ResourceClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClass { return vs[0].(map[string]*ResourceClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClassList.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClassList.go index 17e9bc6c14..f93a729c8d 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClassList.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // ResourceClassList is a collection of classes. @@ -117,6 +118,12 @@ func (i *ResourceClassList) ToResourceClassListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListOutput) } +func (i *ResourceClassList) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassList] { + return pulumix.Output[*ResourceClassList]{ + OutputState: i.ToResourceClassListOutputWithContext(ctx).OutputState, + } +} + // ResourceClassListArrayInput is an input type that accepts ResourceClassListArray and ResourceClassListArrayOutput values. // You can construct a concrete instance of `ResourceClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i ResourceClassListArray) ToResourceClassListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListArrayOutput) } +func (i ResourceClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassList] { + return pulumix.Output[[]*ResourceClassList]{ + OutputState: i.ToResourceClassListArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClassListMapInput is an input type that accepts ResourceClassListMap and ResourceClassListMapOutput values. // You can construct a concrete instance of `ResourceClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i ResourceClassListMap) ToResourceClassListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListMapOutput) } +func (i ResourceClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassList] { + return pulumix.Output[map[string]*ResourceClassList]{ + OutputState: i.ToResourceClassListMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClassListOutput struct{ *pulumi.OutputState } func (ResourceClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o ResourceClassListOutput) ToResourceClassListOutputWithContext(ctx contex return o } +func (o ResourceClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassList] { + return pulumix.Output[*ResourceClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *ResourceClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o ResourceClassListArrayOutput) ToResourceClassListArrayOutputWithContext( return o } +func (o ResourceClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassList] { + return pulumix.Output[[]*ResourceClassList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassListArrayOutput) Index(i pulumi.IntInput) ResourceClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClassList { return vs[0].([]*ResourceClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o ResourceClassListMapOutput) ToResourceClassListMapOutputWithContext(ctx return o } +func (o ResourceClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassList] { + return pulumix.Output[map[string]*ResourceClassList]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassListMapOutput) MapIndex(k pulumi.StringInput) ResourceClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClassList { return vs[0].(map[string]*ResourceClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/resource/v1alpha2/resourceClassPatch.go b/sdk/go/kubernetes/resource/v1alpha2/resourceClassPatch.go index 515b516d28..389ba6cb20 100644 --- a/sdk/go/kubernetes/resource/v1alpha2/resourceClassPatch.go +++ b/sdk/go/kubernetes/resource/v1alpha2/resourceClassPatch.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -152,6 +153,12 @@ func (i *ResourceClassPatch) ToResourceClassPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchOutput) } +func (i *ResourceClassPatch) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassPatch] { + return pulumix.Output[*ResourceClassPatch]{ + OutputState: i.ToResourceClassPatchOutputWithContext(ctx).OutputState, + } +} + // ResourceClassPatchArrayInput is an input type that accepts ResourceClassPatchArray and ResourceClassPatchArrayOutput values. // You can construct a concrete instance of `ResourceClassPatchArrayInput` via: // @@ -177,6 +184,12 @@ func (i ResourceClassPatchArray) ToResourceClassPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchArrayOutput) } +func (i ResourceClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassPatch] { + return pulumix.Output[[]*ResourceClassPatch]{ + OutputState: i.ToResourceClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // ResourceClassPatchMapInput is an input type that accepts ResourceClassPatchMap and ResourceClassPatchMapOutput values. // You can construct a concrete instance of `ResourceClassPatchMapInput` via: // @@ -202,6 +215,12 @@ func (i ResourceClassPatchMap) ToResourceClassPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchMapOutput) } +func (i ResourceClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassPatch] { + return pulumix.Output[map[string]*ResourceClassPatch]{ + OutputState: i.ToResourceClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type ResourceClassPatchOutput struct{ *pulumi.OutputState } func (ResourceClassPatchOutput) ElementType() reflect.Type { @@ -216,6 +235,12 @@ func (o ResourceClassPatchOutput) ToResourceClassPatchOutputWithContext(ctx cont return o } +func (o ResourceClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*ResourceClassPatch] { + return pulumix.Output[*ResourceClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o ResourceClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *ResourceClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -264,6 +289,12 @@ func (o ResourceClassPatchArrayOutput) ToResourceClassPatchArrayOutputWithContex return o } +func (o ResourceClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ResourceClassPatch] { + return pulumix.Output[[]*ResourceClassPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassPatchArrayOutput) Index(i pulumi.IntInput) ResourceClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourceClassPatch { return vs[0].([]*ResourceClassPatch)[vs[1].(int)] @@ -284,6 +315,12 @@ func (o ResourceClassPatchMapOutput) ToResourceClassPatchMapOutputWithContext(ct return o } +func (o ResourceClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ResourceClassPatch] { + return pulumix.Output[map[string]*ResourceClassPatch]{ + OutputState: o.OutputState, + } +} + func (o ResourceClassPatchMapOutput) MapIndex(k pulumi.StringInput) ResourceClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourceClassPatch { return vs[0].(map[string]*ResourceClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1/priorityClass.go b/sdk/go/kubernetes/scheduling/v1/priorityClass.go index f619b51840..6a65fcf44e 100644 --- a/sdk/go/kubernetes/scheduling/v1/priorityClass.go +++ b/sdk/go/kubernetes/scheduling/v1/priorityClass.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. @@ -144,6 +145,12 @@ func (i *PriorityClass) ToPriorityClassOutputWithContext(ctx context.Context) Pr return pulumi.ToOutputWithContext(ctx, i).(PriorityClassOutput) } +func (i *PriorityClass) ToOutput(ctx context.Context) pulumix.Output[*PriorityClass] { + return pulumix.Output[*PriorityClass]{ + OutputState: i.ToPriorityClassOutputWithContext(ctx).OutputState, + } +} + // PriorityClassArrayInput is an input type that accepts PriorityClassArray and PriorityClassArrayOutput values. // You can construct a concrete instance of `PriorityClassArrayInput` via: // @@ -169,6 +176,12 @@ func (i PriorityClassArray) ToPriorityClassArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassArrayOutput) } +func (i PriorityClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClass] { + return pulumix.Output[[]*PriorityClass]{ + OutputState: i.ToPriorityClassArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassMapInput is an input type that accepts PriorityClassMap and PriorityClassMapOutput values. // You can construct a concrete instance of `PriorityClassMapInput` via: // @@ -194,6 +207,12 @@ func (i PriorityClassMap) ToPriorityClassMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PriorityClassMapOutput) } +func (i PriorityClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClass] { + return pulumix.Output[map[string]*PriorityClass]{ + OutputState: i.ToPriorityClassMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassOutput struct{ *pulumi.OutputState } func (PriorityClassOutput) ElementType() reflect.Type { @@ -208,6 +227,12 @@ func (o PriorityClassOutput) ToPriorityClassOutputWithContext(ctx context.Contex return o } +func (o PriorityClassOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClass] { + return pulumix.Output[*PriorityClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -257,6 +282,12 @@ func (o PriorityClassArrayOutput) ToPriorityClassArrayOutputWithContext(ctx cont return o } +func (o PriorityClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClass] { + return pulumix.Output[[]*PriorityClass]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassArrayOutput) Index(i pulumi.IntInput) PriorityClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClass { return vs[0].([]*PriorityClass)[vs[1].(int)] @@ -277,6 +308,12 @@ func (o PriorityClassMapOutput) ToPriorityClassMapOutputWithContext(ctx context. return o } +func (o PriorityClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClass] { + return pulumix.Output[map[string]*PriorityClass]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassMapOutput) MapIndex(k pulumi.StringInput) PriorityClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClass { return vs[0].(map[string]*PriorityClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1/priorityClassList.go b/sdk/go/kubernetes/scheduling/v1/priorityClassList.go index e045a182f4..2c61723716 100644 --- a/sdk/go/kubernetes/scheduling/v1/priorityClassList.go +++ b/sdk/go/kubernetes/scheduling/v1/priorityClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityClassList is a collection of priority classes. @@ -117,6 +118,12 @@ func (i *PriorityClassList) ToPriorityClassListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListOutput) } +func (i *PriorityClassList) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassList] { + return pulumix.Output[*PriorityClassList]{ + OutputState: i.ToPriorityClassListOutputWithContext(ctx).OutputState, + } +} + // PriorityClassListArrayInput is an input type that accepts PriorityClassListArray and PriorityClassListArrayOutput values. // You can construct a concrete instance of `PriorityClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityClassListArray) ToPriorityClassListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListArrayOutput) } +func (i PriorityClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassList] { + return pulumix.Output[[]*PriorityClassList]{ + OutputState: i.ToPriorityClassListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassListMapInput is an input type that accepts PriorityClassListMap and PriorityClassListMapOutput values. // You can construct a concrete instance of `PriorityClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityClassListMap) ToPriorityClassListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListMapOutput) } +func (i PriorityClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassList] { + return pulumix.Output[map[string]*PriorityClassList]{ + OutputState: i.ToPriorityClassListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassListOutput struct{ *pulumi.OutputState } func (PriorityClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityClassListOutput) ToPriorityClassListOutputWithContext(ctx contex return o } +func (o PriorityClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassList] { + return pulumix.Output[*PriorityClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityClassListArrayOutput) ToPriorityClassListArrayOutputWithContext( return o } +func (o PriorityClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassList] { + return pulumix.Output[[]*PriorityClassList]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassListArrayOutput) Index(i pulumi.IntInput) PriorityClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClassList { return vs[0].([]*PriorityClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityClassListMapOutput) ToPriorityClassListMapOutputWithContext(ctx return o } +func (o PriorityClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassList] { + return pulumix.Output[map[string]*PriorityClassList]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassListMapOutput) MapIndex(k pulumi.StringInput) PriorityClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClassList { return vs[0].(map[string]*PriorityClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1/priorityClassPatch.go b/sdk/go/kubernetes/scheduling/v1/priorityClassPatch.go index 032227e012..8f17d4a854 100644 --- a/sdk/go/kubernetes/scheduling/v1/priorityClassPatch.go +++ b/sdk/go/kubernetes/scheduling/v1/priorityClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -146,6 +147,12 @@ func (i *PriorityClassPatch) ToPriorityClassPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchOutput) } +func (i *PriorityClassPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassPatch] { + return pulumix.Output[*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityClassPatchArrayInput is an input type that accepts PriorityClassPatchArray and PriorityClassPatchArrayOutput values. // You can construct a concrete instance of `PriorityClassPatchArrayInput` via: // @@ -171,6 +178,12 @@ func (i PriorityClassPatchArray) ToPriorityClassPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchArrayOutput) } +func (i PriorityClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassPatch] { + return pulumix.Output[[]*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassPatchMapInput is an input type that accepts PriorityClassPatchMap and PriorityClassPatchMapOutput values. // You can construct a concrete instance of `PriorityClassPatchMapInput` via: // @@ -196,6 +209,12 @@ func (i PriorityClassPatchMap) ToPriorityClassPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchMapOutput) } +func (i PriorityClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassPatch] { + return pulumix.Output[map[string]*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassPatchOutput struct{ *pulumi.OutputState } func (PriorityClassPatchOutput) ElementType() reflect.Type { @@ -210,6 +229,12 @@ func (o PriorityClassPatchOutput) ToPriorityClassPatchOutputWithContext(ctx cont return o } +func (o PriorityClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassPatch] { + return pulumix.Output[*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -259,6 +284,12 @@ func (o PriorityClassPatchArrayOutput) ToPriorityClassPatchArrayOutputWithContex return o } +func (o PriorityClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassPatch] { + return pulumix.Output[[]*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassPatchArrayOutput) Index(i pulumi.IntInput) PriorityClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClassPatch { return vs[0].([]*PriorityClassPatch)[vs[1].(int)] @@ -279,6 +310,12 @@ func (o PriorityClassPatchMapOutput) ToPriorityClassPatchMapOutputWithContext(ct return o } +func (o PriorityClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassPatch] { + return pulumix.Output[map[string]*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClassPatch { return vs[0].(map[string]*PriorityClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1/pulumiTypes.go b/sdk/go/kubernetes/scheduling/v1/pulumiTypes.go index 93aedd038b..ed9b3624b4 100644 --- a/sdk/go/kubernetes/scheduling/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/scheduling/v1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -73,6 +74,12 @@ func (i PriorityClassTypeArgs) ToPriorityClassTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PriorityClassTypeOutput) } +func (i PriorityClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassType] { + return pulumix.Output[PriorityClassType]{ + OutputState: i.ToPriorityClassTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClassTypeArrayInput is an input type that accepts PriorityClassTypeArray and PriorityClassTypeArrayOutput values. // You can construct a concrete instance of `PriorityClassTypeArrayInput` via: // @@ -98,6 +105,12 @@ func (i PriorityClassTypeArray) ToPriorityClassTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassTypeArrayOutput) } +func (i PriorityClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityClassType] { + return pulumix.Output[[]PriorityClassType]{ + OutputState: i.ToPriorityClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. type PriorityClassTypeOutput struct{ *pulumi.OutputState } @@ -113,6 +126,12 @@ func (o PriorityClassTypeOutput) ToPriorityClassTypeOutputWithContext(ctx contex return o } +func (o PriorityClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassType] { + return pulumix.Output[PriorityClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -162,6 +181,12 @@ func (o PriorityClassTypeArrayOutput) ToPriorityClassTypeArrayOutputWithContext( return o } +func (o PriorityClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityClassType] { + return pulumix.Output[[]PriorityClassType]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassTypeArrayOutput) Index(i pulumi.IntInput) PriorityClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityClassType { return vs[0].([]PriorityClassType)[vs[1].(int)] @@ -215,6 +240,12 @@ func (i PriorityClassListTypeArgs) ToPriorityClassListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListTypeOutput) } +func (i PriorityClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassListType] { + return pulumix.Output[PriorityClassListType]{ + OutputState: i.ToPriorityClassListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClassList is a collection of priority classes. type PriorityClassListTypeOutput struct{ *pulumi.OutputState } @@ -230,6 +261,12 @@ func (o PriorityClassListTypeOutput) ToPriorityClassListTypeOutputWithContext(ct return o } +func (o PriorityClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassListType] { + return pulumix.Output[PriorityClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -309,6 +346,12 @@ func (i PriorityClassPatchTypeArgs) ToPriorityClassPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchTypeOutput) } +func (i PriorityClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassPatchType] { + return pulumix.Output[PriorityClassPatchType]{ + OutputState: i.ToPriorityClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. type PriorityClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -324,6 +367,12 @@ func (o PriorityClassPatchTypeOutput) ToPriorityClassPatchTypeOutputWithContext( return o } +func (o PriorityClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassPatchType] { + return pulumix.Output[PriorityClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) diff --git a/sdk/go/kubernetes/scheduling/v1alpha1/priorityClass.go b/sdk/go/kubernetes/scheduling/v1alpha1/priorityClass.go index 886a35deee..bc83ed11dc 100644 --- a/sdk/go/kubernetes/scheduling/v1alpha1/priorityClass.go +++ b/sdk/go/kubernetes/scheduling/v1alpha1/priorityClass.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. @@ -144,6 +145,12 @@ func (i *PriorityClass) ToPriorityClassOutputWithContext(ctx context.Context) Pr return pulumi.ToOutputWithContext(ctx, i).(PriorityClassOutput) } +func (i *PriorityClass) ToOutput(ctx context.Context) pulumix.Output[*PriorityClass] { + return pulumix.Output[*PriorityClass]{ + OutputState: i.ToPriorityClassOutputWithContext(ctx).OutputState, + } +} + // PriorityClassArrayInput is an input type that accepts PriorityClassArray and PriorityClassArrayOutput values. // You can construct a concrete instance of `PriorityClassArrayInput` via: // @@ -169,6 +176,12 @@ func (i PriorityClassArray) ToPriorityClassArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassArrayOutput) } +func (i PriorityClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClass] { + return pulumix.Output[[]*PriorityClass]{ + OutputState: i.ToPriorityClassArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassMapInput is an input type that accepts PriorityClassMap and PriorityClassMapOutput values. // You can construct a concrete instance of `PriorityClassMapInput` via: // @@ -194,6 +207,12 @@ func (i PriorityClassMap) ToPriorityClassMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PriorityClassMapOutput) } +func (i PriorityClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClass] { + return pulumix.Output[map[string]*PriorityClass]{ + OutputState: i.ToPriorityClassMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassOutput struct{ *pulumi.OutputState } func (PriorityClassOutput) ElementType() reflect.Type { @@ -208,6 +227,12 @@ func (o PriorityClassOutput) ToPriorityClassOutputWithContext(ctx context.Contex return o } +func (o PriorityClassOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClass] { + return pulumix.Output[*PriorityClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -257,6 +282,12 @@ func (o PriorityClassArrayOutput) ToPriorityClassArrayOutputWithContext(ctx cont return o } +func (o PriorityClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClass] { + return pulumix.Output[[]*PriorityClass]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassArrayOutput) Index(i pulumi.IntInput) PriorityClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClass { return vs[0].([]*PriorityClass)[vs[1].(int)] @@ -277,6 +308,12 @@ func (o PriorityClassMapOutput) ToPriorityClassMapOutputWithContext(ctx context. return o } +func (o PriorityClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClass] { + return pulumix.Output[map[string]*PriorityClass]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassMapOutput) MapIndex(k pulumi.StringInput) PriorityClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClass { return vs[0].(map[string]*PriorityClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassList.go b/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassList.go index 0c8be75e5f..4f92b8892e 100644 --- a/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassList.go +++ b/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityClassList is a collection of priority classes. @@ -117,6 +118,12 @@ func (i *PriorityClassList) ToPriorityClassListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListOutput) } +func (i *PriorityClassList) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassList] { + return pulumix.Output[*PriorityClassList]{ + OutputState: i.ToPriorityClassListOutputWithContext(ctx).OutputState, + } +} + // PriorityClassListArrayInput is an input type that accepts PriorityClassListArray and PriorityClassListArrayOutput values. // You can construct a concrete instance of `PriorityClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityClassListArray) ToPriorityClassListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListArrayOutput) } +func (i PriorityClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassList] { + return pulumix.Output[[]*PriorityClassList]{ + OutputState: i.ToPriorityClassListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassListMapInput is an input type that accepts PriorityClassListMap and PriorityClassListMapOutput values. // You can construct a concrete instance of `PriorityClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityClassListMap) ToPriorityClassListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListMapOutput) } +func (i PriorityClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassList] { + return pulumix.Output[map[string]*PriorityClassList]{ + OutputState: i.ToPriorityClassListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassListOutput struct{ *pulumi.OutputState } func (PriorityClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityClassListOutput) ToPriorityClassListOutputWithContext(ctx contex return o } +func (o PriorityClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassList] { + return pulumix.Output[*PriorityClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityClassListArrayOutput) ToPriorityClassListArrayOutputWithContext( return o } +func (o PriorityClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassList] { + return pulumix.Output[[]*PriorityClassList]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassListArrayOutput) Index(i pulumi.IntInput) PriorityClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClassList { return vs[0].([]*PriorityClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityClassListMapOutput) ToPriorityClassListMapOutputWithContext(ctx return o } +func (o PriorityClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassList] { + return pulumix.Output[map[string]*PriorityClassList]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassListMapOutput) MapIndex(k pulumi.StringInput) PriorityClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClassList { return vs[0].(map[string]*PriorityClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassPatch.go b/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassPatch.go index f02fdac766..bdbf476156 100644 --- a/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassPatch.go +++ b/sdk/go/kubernetes/scheduling/v1alpha1/priorityClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -146,6 +147,12 @@ func (i *PriorityClassPatch) ToPriorityClassPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchOutput) } +func (i *PriorityClassPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassPatch] { + return pulumix.Output[*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityClassPatchArrayInput is an input type that accepts PriorityClassPatchArray and PriorityClassPatchArrayOutput values. // You can construct a concrete instance of `PriorityClassPatchArrayInput` via: // @@ -171,6 +178,12 @@ func (i PriorityClassPatchArray) ToPriorityClassPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchArrayOutput) } +func (i PriorityClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassPatch] { + return pulumix.Output[[]*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassPatchMapInput is an input type that accepts PriorityClassPatchMap and PriorityClassPatchMapOutput values. // You can construct a concrete instance of `PriorityClassPatchMapInput` via: // @@ -196,6 +209,12 @@ func (i PriorityClassPatchMap) ToPriorityClassPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchMapOutput) } +func (i PriorityClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassPatch] { + return pulumix.Output[map[string]*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassPatchOutput struct{ *pulumi.OutputState } func (PriorityClassPatchOutput) ElementType() reflect.Type { @@ -210,6 +229,12 @@ func (o PriorityClassPatchOutput) ToPriorityClassPatchOutputWithContext(ctx cont return o } +func (o PriorityClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassPatch] { + return pulumix.Output[*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -259,6 +284,12 @@ func (o PriorityClassPatchArrayOutput) ToPriorityClassPatchArrayOutputWithContex return o } +func (o PriorityClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassPatch] { + return pulumix.Output[[]*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassPatchArrayOutput) Index(i pulumi.IntInput) PriorityClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClassPatch { return vs[0].([]*PriorityClassPatch)[vs[1].(int)] @@ -279,6 +310,12 @@ func (o PriorityClassPatchMapOutput) ToPriorityClassPatchMapOutputWithContext(ct return o } +func (o PriorityClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassPatch] { + return pulumix.Output[map[string]*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClassPatch { return vs[0].(map[string]*PriorityClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/scheduling/v1alpha1/pulumiTypes.go index d7b946ec5b..b0efba5f8d 100644 --- a/sdk/go/kubernetes/scheduling/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/scheduling/v1alpha1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -73,6 +74,12 @@ func (i PriorityClassTypeArgs) ToPriorityClassTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PriorityClassTypeOutput) } +func (i PriorityClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassType] { + return pulumix.Output[PriorityClassType]{ + OutputState: i.ToPriorityClassTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClassTypeArrayInput is an input type that accepts PriorityClassTypeArray and PriorityClassTypeArrayOutput values. // You can construct a concrete instance of `PriorityClassTypeArrayInput` via: // @@ -98,6 +105,12 @@ func (i PriorityClassTypeArray) ToPriorityClassTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassTypeArrayOutput) } +func (i PriorityClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityClassType] { + return pulumix.Output[[]PriorityClassType]{ + OutputState: i.ToPriorityClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. type PriorityClassTypeOutput struct{ *pulumi.OutputState } @@ -113,6 +126,12 @@ func (o PriorityClassTypeOutput) ToPriorityClassTypeOutputWithContext(ctx contex return o } +func (o PriorityClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassType] { + return pulumix.Output[PriorityClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -162,6 +181,12 @@ func (o PriorityClassTypeArrayOutput) ToPriorityClassTypeArrayOutputWithContext( return o } +func (o PriorityClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityClassType] { + return pulumix.Output[[]PriorityClassType]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassTypeArrayOutput) Index(i pulumi.IntInput) PriorityClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityClassType { return vs[0].([]PriorityClassType)[vs[1].(int)] @@ -215,6 +240,12 @@ func (i PriorityClassListTypeArgs) ToPriorityClassListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListTypeOutput) } +func (i PriorityClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassListType] { + return pulumix.Output[PriorityClassListType]{ + OutputState: i.ToPriorityClassListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClassList is a collection of priority classes. type PriorityClassListTypeOutput struct{ *pulumi.OutputState } @@ -230,6 +261,12 @@ func (o PriorityClassListTypeOutput) ToPriorityClassListTypeOutputWithContext(ct return o } +func (o PriorityClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassListType] { + return pulumix.Output[PriorityClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -309,6 +346,12 @@ func (i PriorityClassPatchTypeArgs) ToPriorityClassPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchTypeOutput) } +func (i PriorityClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassPatchType] { + return pulumix.Output[PriorityClassPatchType]{ + OutputState: i.ToPriorityClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. type PriorityClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -324,6 +367,12 @@ func (o PriorityClassPatchTypeOutput) ToPriorityClassPatchTypeOutputWithContext( return o } +func (o PriorityClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassPatchType] { + return pulumix.Output[PriorityClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) diff --git a/sdk/go/kubernetes/scheduling/v1beta1/priorityClass.go b/sdk/go/kubernetes/scheduling/v1beta1/priorityClass.go index 6e53f773b0..3e46beaf4a 100644 --- a/sdk/go/kubernetes/scheduling/v1beta1/priorityClass.go +++ b/sdk/go/kubernetes/scheduling/v1beta1/priorityClass.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. @@ -144,6 +145,12 @@ func (i *PriorityClass) ToPriorityClassOutputWithContext(ctx context.Context) Pr return pulumi.ToOutputWithContext(ctx, i).(PriorityClassOutput) } +func (i *PriorityClass) ToOutput(ctx context.Context) pulumix.Output[*PriorityClass] { + return pulumix.Output[*PriorityClass]{ + OutputState: i.ToPriorityClassOutputWithContext(ctx).OutputState, + } +} + // PriorityClassArrayInput is an input type that accepts PriorityClassArray and PriorityClassArrayOutput values. // You can construct a concrete instance of `PriorityClassArrayInput` via: // @@ -169,6 +176,12 @@ func (i PriorityClassArray) ToPriorityClassArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassArrayOutput) } +func (i PriorityClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClass] { + return pulumix.Output[[]*PriorityClass]{ + OutputState: i.ToPriorityClassArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassMapInput is an input type that accepts PriorityClassMap and PriorityClassMapOutput values. // You can construct a concrete instance of `PriorityClassMapInput` via: // @@ -194,6 +207,12 @@ func (i PriorityClassMap) ToPriorityClassMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PriorityClassMapOutput) } +func (i PriorityClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClass] { + return pulumix.Output[map[string]*PriorityClass]{ + OutputState: i.ToPriorityClassMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassOutput struct{ *pulumi.OutputState } func (PriorityClassOutput) ElementType() reflect.Type { @@ -208,6 +227,12 @@ func (o PriorityClassOutput) ToPriorityClassOutputWithContext(ctx context.Contex return o } +func (o PriorityClassOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClass] { + return pulumix.Output[*PriorityClass]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityClass) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -257,6 +282,12 @@ func (o PriorityClassArrayOutput) ToPriorityClassArrayOutputWithContext(ctx cont return o } +func (o PriorityClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClass] { + return pulumix.Output[[]*PriorityClass]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassArrayOutput) Index(i pulumi.IntInput) PriorityClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClass { return vs[0].([]*PriorityClass)[vs[1].(int)] @@ -277,6 +308,12 @@ func (o PriorityClassMapOutput) ToPriorityClassMapOutputWithContext(ctx context. return o } +func (o PriorityClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClass] { + return pulumix.Output[map[string]*PriorityClass]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassMapOutput) MapIndex(k pulumi.StringInput) PriorityClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClass { return vs[0].(map[string]*PriorityClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1beta1/priorityClassList.go b/sdk/go/kubernetes/scheduling/v1beta1/priorityClassList.go index c567f1b108..739ebcdf7d 100644 --- a/sdk/go/kubernetes/scheduling/v1beta1/priorityClassList.go +++ b/sdk/go/kubernetes/scheduling/v1beta1/priorityClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PriorityClassList is a collection of priority classes. @@ -117,6 +118,12 @@ func (i *PriorityClassList) ToPriorityClassListOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListOutput) } +func (i *PriorityClassList) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassList] { + return pulumix.Output[*PriorityClassList]{ + OutputState: i.ToPriorityClassListOutputWithContext(ctx).OutputState, + } +} + // PriorityClassListArrayInput is an input type that accepts PriorityClassListArray and PriorityClassListArrayOutput values. // You can construct a concrete instance of `PriorityClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PriorityClassListArray) ToPriorityClassListArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListArrayOutput) } +func (i PriorityClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassList] { + return pulumix.Output[[]*PriorityClassList]{ + OutputState: i.ToPriorityClassListArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassListMapInput is an input type that accepts PriorityClassListMap and PriorityClassListMapOutput values. // You can construct a concrete instance of `PriorityClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i PriorityClassListMap) ToPriorityClassListMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListMapOutput) } +func (i PriorityClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassList] { + return pulumix.Output[map[string]*PriorityClassList]{ + OutputState: i.ToPriorityClassListMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassListOutput struct{ *pulumi.OutputState } func (PriorityClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PriorityClassListOutput) ToPriorityClassListOutputWithContext(ctx contex return o } +func (o PriorityClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassList] { + return pulumix.Output[*PriorityClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PriorityClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PriorityClassListArrayOutput) ToPriorityClassListArrayOutputWithContext( return o } +func (o PriorityClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassList] { + return pulumix.Output[[]*PriorityClassList]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassListArrayOutput) Index(i pulumi.IntInput) PriorityClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClassList { return vs[0].([]*PriorityClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PriorityClassListMapOutput) ToPriorityClassListMapOutputWithContext(ctx return o } +func (o PriorityClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassList] { + return pulumix.Output[map[string]*PriorityClassList]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassListMapOutput) MapIndex(k pulumi.StringInput) PriorityClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClassList { return vs[0].(map[string]*PriorityClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1beta1/priorityClassPatch.go b/sdk/go/kubernetes/scheduling/v1beta1/priorityClassPatch.go index dbda4cf3a1..6d88a4658c 100644 --- a/sdk/go/kubernetes/scheduling/v1beta1/priorityClassPatch.go +++ b/sdk/go/kubernetes/scheduling/v1beta1/priorityClassPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -146,6 +147,12 @@ func (i *PriorityClassPatch) ToPriorityClassPatchOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchOutput) } +func (i *PriorityClassPatch) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassPatch] { + return pulumix.Output[*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchOutputWithContext(ctx).OutputState, + } +} + // PriorityClassPatchArrayInput is an input type that accepts PriorityClassPatchArray and PriorityClassPatchArrayOutput values. // You can construct a concrete instance of `PriorityClassPatchArrayInput` via: // @@ -171,6 +178,12 @@ func (i PriorityClassPatchArray) ToPriorityClassPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchArrayOutput) } +func (i PriorityClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassPatch] { + return pulumix.Output[[]*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PriorityClassPatchMapInput is an input type that accepts PriorityClassPatchMap and PriorityClassPatchMapOutput values. // You can construct a concrete instance of `PriorityClassPatchMapInput` via: // @@ -196,6 +209,12 @@ func (i PriorityClassPatchMap) ToPriorityClassPatchMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchMapOutput) } +func (i PriorityClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassPatch] { + return pulumix.Output[map[string]*PriorityClassPatch]{ + OutputState: i.ToPriorityClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type PriorityClassPatchOutput struct{ *pulumi.OutputState } func (PriorityClassPatchOutput) ElementType() reflect.Type { @@ -210,6 +229,12 @@ func (o PriorityClassPatchOutput) ToPriorityClassPatchOutputWithContext(ctx cont return o } +func (o PriorityClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PriorityClassPatch] { + return pulumix.Output[*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PriorityClassPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -259,6 +284,12 @@ func (o PriorityClassPatchArrayOutput) ToPriorityClassPatchArrayOutputWithContex return o } +func (o PriorityClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PriorityClassPatch] { + return pulumix.Output[[]*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassPatchArrayOutput) Index(i pulumi.IntInput) PriorityClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PriorityClassPatch { return vs[0].([]*PriorityClassPatch)[vs[1].(int)] @@ -279,6 +310,12 @@ func (o PriorityClassPatchMapOutput) ToPriorityClassPatchMapOutputWithContext(ct return o } +func (o PriorityClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PriorityClassPatch] { + return pulumix.Output[map[string]*PriorityClassPatch]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassPatchMapOutput) MapIndex(k pulumi.StringInput) PriorityClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PriorityClassPatch { return vs[0].(map[string]*PriorityClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/scheduling/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/scheduling/v1beta1/pulumiTypes.go index 1291caa223..4bd6252719 100644 --- a/sdk/go/kubernetes/scheduling/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/scheduling/v1beta1/pulumiTypes.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -73,6 +74,12 @@ func (i PriorityClassTypeArgs) ToPriorityClassTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PriorityClassTypeOutput) } +func (i PriorityClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassType] { + return pulumix.Output[PriorityClassType]{ + OutputState: i.ToPriorityClassTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClassTypeArrayInput is an input type that accepts PriorityClassTypeArray and PriorityClassTypeArrayOutput values. // You can construct a concrete instance of `PriorityClassTypeArrayInput` via: // @@ -98,6 +105,12 @@ func (i PriorityClassTypeArray) ToPriorityClassTypeArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(PriorityClassTypeArrayOutput) } +func (i PriorityClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PriorityClassType] { + return pulumix.Output[[]PriorityClassType]{ + OutputState: i.ToPriorityClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. type PriorityClassTypeOutput struct{ *pulumi.OutputState } @@ -113,6 +126,12 @@ func (o PriorityClassTypeOutput) ToPriorityClassTypeOutputWithContext(ctx contex return o } +func (o PriorityClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassType] { + return pulumix.Output[PriorityClassType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -162,6 +181,12 @@ func (o PriorityClassTypeArrayOutput) ToPriorityClassTypeArrayOutputWithContext( return o } +func (o PriorityClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PriorityClassType] { + return pulumix.Output[[]PriorityClassType]{ + OutputState: o.OutputState, + } +} + func (o PriorityClassTypeArrayOutput) Index(i pulumi.IntInput) PriorityClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PriorityClassType { return vs[0].([]PriorityClassType)[vs[1].(int)] @@ -215,6 +240,12 @@ func (i PriorityClassListTypeArgs) ToPriorityClassListTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PriorityClassListTypeOutput) } +func (i PriorityClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassListType] { + return pulumix.Output[PriorityClassListType]{ + OutputState: i.ToPriorityClassListTypeOutputWithContext(ctx).OutputState, + } +} + // PriorityClassList is a collection of priority classes. type PriorityClassListTypeOutput struct{ *pulumi.OutputState } @@ -230,6 +261,12 @@ func (o PriorityClassListTypeOutput) ToPriorityClassListTypeOutputWithContext(ct return o } +func (o PriorityClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassListType] { + return pulumix.Output[PriorityClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -309,6 +346,12 @@ func (i PriorityClassPatchTypeArgs) ToPriorityClassPatchTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(PriorityClassPatchTypeOutput) } +func (i PriorityClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PriorityClassPatchType] { + return pulumix.Output[PriorityClassPatchType]{ + OutputState: i.ToPriorityClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. type PriorityClassPatchTypeOutput struct{ *pulumi.OutputState } @@ -324,6 +367,12 @@ func (o PriorityClassPatchTypeOutput) ToPriorityClassPatchTypeOutputWithContext( return o } +func (o PriorityClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PriorityClassPatchType] { + return pulumix.Output[PriorityClassPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PriorityClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PriorityClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) diff --git a/sdk/go/kubernetes/settings/v1alpha1/podPreset.go b/sdk/go/kubernetes/settings/v1alpha1/podPreset.go index a1b07ede80..b7bdac0a12 100644 --- a/sdk/go/kubernetes/settings/v1alpha1/podPreset.go +++ b/sdk/go/kubernetes/settings/v1alpha1/podPreset.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodPreset is a policy resource that defines additional runtime requirements for a Pod. @@ -107,6 +108,12 @@ func (i *PodPreset) ToPodPresetOutputWithContext(ctx context.Context) PodPresetO return pulumi.ToOutputWithContext(ctx, i).(PodPresetOutput) } +func (i *PodPreset) ToOutput(ctx context.Context) pulumix.Output[*PodPreset] { + return pulumix.Output[*PodPreset]{ + OutputState: i.ToPodPresetOutputWithContext(ctx).OutputState, + } +} + // PodPresetArrayInput is an input type that accepts PodPresetArray and PodPresetArrayOutput values. // You can construct a concrete instance of `PodPresetArrayInput` via: // @@ -132,6 +139,12 @@ func (i PodPresetArray) ToPodPresetArrayOutputWithContext(ctx context.Context) P return pulumi.ToOutputWithContext(ctx, i).(PodPresetArrayOutput) } +func (i PodPresetArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodPreset] { + return pulumix.Output[[]*PodPreset]{ + OutputState: i.ToPodPresetArrayOutputWithContext(ctx).OutputState, + } +} + // PodPresetMapInput is an input type that accepts PodPresetMap and PodPresetMapOutput values. // You can construct a concrete instance of `PodPresetMapInput` via: // @@ -157,6 +170,12 @@ func (i PodPresetMap) ToPodPresetMapOutputWithContext(ctx context.Context) PodPr return pulumi.ToOutputWithContext(ctx, i).(PodPresetMapOutput) } +func (i PodPresetMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPreset] { + return pulumix.Output[map[string]*PodPreset]{ + OutputState: i.ToPodPresetMapOutputWithContext(ctx).OutputState, + } +} + type PodPresetOutput struct{ *pulumi.OutputState } func (PodPresetOutput) ElementType() reflect.Type { @@ -171,6 +190,12 @@ func (o PodPresetOutput) ToPodPresetOutputWithContext(ctx context.Context) PodPr return o } +func (o PodPresetOutput) ToOutput(ctx context.Context) pulumix.Output[*PodPreset] { + return pulumix.Output[*PodPreset]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPresetOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodPreset) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -203,6 +228,12 @@ func (o PodPresetArrayOutput) ToPodPresetArrayOutputWithContext(ctx context.Cont return o } +func (o PodPresetArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodPreset] { + return pulumix.Output[[]*PodPreset]{ + OutputState: o.OutputState, + } +} + func (o PodPresetArrayOutput) Index(i pulumi.IntInput) PodPresetOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodPreset { return vs[0].([]*PodPreset)[vs[1].(int)] @@ -223,6 +254,12 @@ func (o PodPresetMapOutput) ToPodPresetMapOutputWithContext(ctx context.Context) return o } +func (o PodPresetMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPreset] { + return pulumix.Output[map[string]*PodPreset]{ + OutputState: o.OutputState, + } +} + func (o PodPresetMapOutput) MapIndex(k pulumi.StringInput) PodPresetOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodPreset { return vs[0].(map[string]*PodPreset)[vs[1].(string)] diff --git a/sdk/go/kubernetes/settings/v1alpha1/podPresetList.go b/sdk/go/kubernetes/settings/v1alpha1/podPresetList.go index 7007f0b449..0a13ee7386 100644 --- a/sdk/go/kubernetes/settings/v1alpha1/podPresetList.go +++ b/sdk/go/kubernetes/settings/v1alpha1/podPresetList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // PodPresetList is a list of PodPreset objects. @@ -117,6 +118,12 @@ func (i *PodPresetList) ToPodPresetListOutputWithContext(ctx context.Context) Po return pulumi.ToOutputWithContext(ctx, i).(PodPresetListOutput) } +func (i *PodPresetList) ToOutput(ctx context.Context) pulumix.Output[*PodPresetList] { + return pulumix.Output[*PodPresetList]{ + OutputState: i.ToPodPresetListOutputWithContext(ctx).OutputState, + } +} + // PodPresetListArrayInput is an input type that accepts PodPresetListArray and PodPresetListArrayOutput values. // You can construct a concrete instance of `PodPresetListArrayInput` via: // @@ -142,6 +149,12 @@ func (i PodPresetListArray) ToPodPresetListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodPresetListArrayOutput) } +func (i PodPresetListArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodPresetList] { + return pulumix.Output[[]*PodPresetList]{ + OutputState: i.ToPodPresetListArrayOutputWithContext(ctx).OutputState, + } +} + // PodPresetListMapInput is an input type that accepts PodPresetListMap and PodPresetListMapOutput values. // You can construct a concrete instance of `PodPresetListMapInput` via: // @@ -167,6 +180,12 @@ func (i PodPresetListMap) ToPodPresetListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(PodPresetListMapOutput) } +func (i PodPresetListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPresetList] { + return pulumix.Output[map[string]*PodPresetList]{ + OutputState: i.ToPodPresetListMapOutputWithContext(ctx).OutputState, + } +} + type PodPresetListOutput struct{ *pulumi.OutputState } func (PodPresetListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o PodPresetListOutput) ToPodPresetListOutputWithContext(ctx context.Contex return o } +func (o PodPresetListOutput) ToOutput(ctx context.Context) pulumix.Output[*PodPresetList] { + return pulumix.Output[*PodPresetList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPresetListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *PodPresetList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o PodPresetListArrayOutput) ToPodPresetListArrayOutputWithContext(ctx cont return o } +func (o PodPresetListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodPresetList] { + return pulumix.Output[[]*PodPresetList]{ + OutputState: o.OutputState, + } +} + func (o PodPresetListArrayOutput) Index(i pulumi.IntInput) PodPresetListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodPresetList { return vs[0].([]*PodPresetList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o PodPresetListMapOutput) ToPodPresetListMapOutputWithContext(ctx context. return o } +func (o PodPresetListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPresetList] { + return pulumix.Output[map[string]*PodPresetList]{ + OutputState: o.OutputState, + } +} + func (o PodPresetListMapOutput) MapIndex(k pulumi.StringInput) PodPresetListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodPresetList { return vs[0].(map[string]*PodPresetList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/settings/v1alpha1/podPresetPatch.go b/sdk/go/kubernetes/settings/v1alpha1/podPresetPatch.go index 2e1e02f1ef..25c2676a51 100644 --- a/sdk/go/kubernetes/settings/v1alpha1/podPresetPatch.go +++ b/sdk/go/kubernetes/settings/v1alpha1/podPresetPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -113,6 +114,12 @@ func (i *PodPresetPatch) ToPodPresetPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PodPresetPatchOutput) } +func (i *PodPresetPatch) ToOutput(ctx context.Context) pulumix.Output[*PodPresetPatch] { + return pulumix.Output[*PodPresetPatch]{ + OutputState: i.ToPodPresetPatchOutputWithContext(ctx).OutputState, + } +} + // PodPresetPatchArrayInput is an input type that accepts PodPresetPatchArray and PodPresetPatchArrayOutput values. // You can construct a concrete instance of `PodPresetPatchArrayInput` via: // @@ -138,6 +145,12 @@ func (i PodPresetPatchArray) ToPodPresetPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodPresetPatchArrayOutput) } +func (i PodPresetPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*PodPresetPatch] { + return pulumix.Output[[]*PodPresetPatch]{ + OutputState: i.ToPodPresetPatchArrayOutputWithContext(ctx).OutputState, + } +} + // PodPresetPatchMapInput is an input type that accepts PodPresetPatchMap and PodPresetPatchMapOutput values. // You can construct a concrete instance of `PodPresetPatchMapInput` via: // @@ -163,6 +176,12 @@ func (i PodPresetPatchMap) ToPodPresetPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(PodPresetPatchMapOutput) } +func (i PodPresetPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPresetPatch] { + return pulumix.Output[map[string]*PodPresetPatch]{ + OutputState: i.ToPodPresetPatchMapOutputWithContext(ctx).OutputState, + } +} + type PodPresetPatchOutput struct{ *pulumi.OutputState } func (PodPresetPatchOutput) ElementType() reflect.Type { @@ -177,6 +196,12 @@ func (o PodPresetPatchOutput) ToPodPresetPatchOutputWithContext(ctx context.Cont return o } +func (o PodPresetPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*PodPresetPatch] { + return pulumix.Output[*PodPresetPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPresetPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *PodPresetPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -209,6 +234,12 @@ func (o PodPresetPatchArrayOutput) ToPodPresetPatchArrayOutputWithContext(ctx co return o } +func (o PodPresetPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PodPresetPatch] { + return pulumix.Output[[]*PodPresetPatch]{ + OutputState: o.OutputState, + } +} + func (o PodPresetPatchArrayOutput) Index(i pulumi.IntInput) PodPresetPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PodPresetPatch { return vs[0].([]*PodPresetPatch)[vs[1].(int)] @@ -229,6 +260,12 @@ func (o PodPresetPatchMapOutput) ToPodPresetPatchMapOutputWithContext(ctx contex return o } +func (o PodPresetPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PodPresetPatch] { + return pulumix.Output[map[string]*PodPresetPatch]{ + OutputState: o.OutputState, + } +} + func (o PodPresetPatchMapOutput) MapIndex(k pulumi.StringInput) PodPresetPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PodPresetPatch { return vs[0].(map[string]*PodPresetPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/settings/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/settings/v1alpha1/pulumiTypes.go index 6c083ea90f..d150c33b73 100644 --- a/sdk/go/kubernetes/settings/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/settings/v1alpha1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -58,6 +59,12 @@ func (i PodPresetTypeArgs) ToPodPresetTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PodPresetTypeOutput) } +func (i PodPresetTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodPresetType] { + return pulumix.Output[PodPresetType]{ + OutputState: i.ToPodPresetTypeOutputWithContext(ctx).OutputState, + } +} + // PodPresetTypeArrayInput is an input type that accepts PodPresetTypeArray and PodPresetTypeArrayOutput values. // You can construct a concrete instance of `PodPresetTypeArrayInput` via: // @@ -83,6 +90,12 @@ func (i PodPresetTypeArray) ToPodPresetTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(PodPresetTypeArrayOutput) } +func (i PodPresetTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]PodPresetType] { + return pulumix.Output[[]PodPresetType]{ + OutputState: i.ToPodPresetTypeArrayOutputWithContext(ctx).OutputState, + } +} + // PodPreset is a policy resource that defines additional runtime requirements for a Pod. type PodPresetTypeOutput struct{ *pulumi.OutputState } @@ -98,6 +111,12 @@ func (o PodPresetTypeOutput) ToPodPresetTypeOutputWithContext(ctx context.Contex return o } +func (o PodPresetTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodPresetType] { + return pulumix.Output[PodPresetType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPresetTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodPresetType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -130,6 +149,12 @@ func (o PodPresetTypeArrayOutput) ToPodPresetTypeArrayOutputWithContext(ctx cont return o } +func (o PodPresetTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PodPresetType] { + return pulumix.Output[[]PodPresetType]{ + OutputState: o.OutputState, + } +} + func (o PodPresetTypeArrayOutput) Index(i pulumi.IntInput) PodPresetTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) PodPresetType { return vs[0].([]PodPresetType)[vs[1].(int)] @@ -183,6 +208,12 @@ func (i PodPresetListTypeArgs) ToPodPresetListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PodPresetListTypeOutput) } +func (i PodPresetListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodPresetListType] { + return pulumix.Output[PodPresetListType]{ + OutputState: i.ToPodPresetListTypeOutputWithContext(ctx).OutputState, + } +} + // PodPresetList is a list of PodPreset objects. type PodPresetListTypeOutput struct{ *pulumi.OutputState } @@ -198,6 +229,12 @@ func (o PodPresetListTypeOutput) ToPodPresetListTypeOutputWithContext(ctx contex return o } +func (o PodPresetListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodPresetListType] { + return pulumix.Output[PodPresetListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPresetListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodPresetListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -261,6 +298,12 @@ func (i PodPresetPatchTypeArgs) ToPodPresetPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodPresetPatchTypeOutput) } +func (i PodPresetPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[PodPresetPatchType] { + return pulumix.Output[PodPresetPatchType]{ + OutputState: i.ToPodPresetPatchTypeOutputWithContext(ctx).OutputState, + } +} + // PodPreset is a policy resource that defines additional runtime requirements for a Pod. type PodPresetPatchTypeOutput struct{ *pulumi.OutputState } @@ -276,6 +319,12 @@ func (o PodPresetPatchTypeOutput) ToPodPresetPatchTypeOutputWithContext(ctx cont return o } +func (o PodPresetPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[PodPresetPatchType] { + return pulumix.Output[PodPresetPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o PodPresetPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v PodPresetPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -345,6 +394,12 @@ func (i PodPresetSpecArgs) ToPodPresetSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(PodPresetSpecOutput) } +func (i PodPresetSpecArgs) ToOutput(ctx context.Context) pulumix.Output[PodPresetSpec] { + return pulumix.Output[PodPresetSpec]{ + OutputState: i.ToPodPresetSpecOutputWithContext(ctx).OutputState, + } +} + func (i PodPresetSpecArgs) ToPodPresetSpecPtrOutput() PodPresetSpecPtrOutput { return i.ToPodPresetSpecPtrOutputWithContext(context.Background()) } @@ -386,6 +441,12 @@ func (i *podPresetSpecPtrType) ToPodPresetSpecPtrOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(PodPresetSpecPtrOutput) } +func (i *podPresetSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodPresetSpec] { + return pulumix.Output[*PodPresetSpec]{ + OutputState: i.ToPodPresetSpecPtrOutputWithContext(ctx).OutputState, + } +} + // PodPresetSpec is a description of a pod preset. type PodPresetSpecOutput struct{ *pulumi.OutputState } @@ -411,6 +472,12 @@ func (o PodPresetSpecOutput) ToPodPresetSpecPtrOutputWithContext(ctx context.Con }).(PodPresetSpecPtrOutput) } +func (o PodPresetSpecOutput) ToOutput(ctx context.Context) pulumix.Output[PodPresetSpec] { + return pulumix.Output[PodPresetSpec]{ + OutputState: o.OutputState, + } +} + // Env defines the collection of EnvVar to inject into containers. func (o PodPresetSpecOutput) Env() corev1.EnvVarArrayOutput { return o.ApplyT(func(v PodPresetSpec) []corev1.EnvVar { return v.Env }).(corev1.EnvVarArrayOutput) @@ -450,6 +517,12 @@ func (o PodPresetSpecPtrOutput) ToPodPresetSpecPtrOutputWithContext(ctx context. return o } +func (o PodPresetSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodPresetSpec] { + return pulumix.Output[*PodPresetSpec]{ + OutputState: o.OutputState, + } +} + func (o PodPresetSpecPtrOutput) Elem() PodPresetSpecOutput { return o.ApplyT(func(v *PodPresetSpec) PodPresetSpec { if v != nil { @@ -561,6 +634,12 @@ func (i PodPresetSpecPatchArgs) ToPodPresetSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(PodPresetSpecPatchOutput) } +func (i PodPresetSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[PodPresetSpecPatch] { + return pulumix.Output[PodPresetSpecPatch]{ + OutputState: i.ToPodPresetSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i PodPresetSpecPatchArgs) ToPodPresetSpecPatchPtrOutput() PodPresetSpecPatchPtrOutput { return i.ToPodPresetSpecPatchPtrOutputWithContext(context.Background()) } @@ -602,6 +681,12 @@ func (i *podPresetSpecPatchPtrType) ToPodPresetSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(PodPresetSpecPatchPtrOutput) } +func (i *podPresetSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*PodPresetSpecPatch] { + return pulumix.Output[*PodPresetSpecPatch]{ + OutputState: i.ToPodPresetSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // PodPresetSpec is a description of a pod preset. type PodPresetSpecPatchOutput struct{ *pulumi.OutputState } @@ -627,6 +712,12 @@ func (o PodPresetSpecPatchOutput) ToPodPresetSpecPatchPtrOutputWithContext(ctx c }).(PodPresetSpecPatchPtrOutput) } +func (o PodPresetSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[PodPresetSpecPatch] { + return pulumix.Output[PodPresetSpecPatch]{ + OutputState: o.OutputState, + } +} + // Env defines the collection of EnvVar to inject into containers. func (o PodPresetSpecPatchOutput) Env() corev1.EnvVarPatchArrayOutput { return o.ApplyT(func(v PodPresetSpecPatch) []corev1.EnvVarPatch { return v.Env }).(corev1.EnvVarPatchArrayOutput) @@ -666,6 +757,12 @@ func (o PodPresetSpecPatchPtrOutput) ToPodPresetSpecPatchPtrOutputWithContext(ct return o } +func (o PodPresetSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PodPresetSpecPatch] { + return pulumix.Output[*PodPresetSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o PodPresetSpecPatchPtrOutput) Elem() PodPresetSpecPatchOutput { return o.ApplyT(func(v *PodPresetSpecPatch) PodPresetSpecPatch { if v != nil { diff --git a/sdk/go/kubernetes/storage/v1/csidriver.go b/sdk/go/kubernetes/storage/v1/csidriver.go index f29053aacf..ae03bbf6d7 100644 --- a/sdk/go/kubernetes/storage/v1/csidriver.go +++ b/sdk/go/kubernetes/storage/v1/csidriver.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. @@ -123,6 +124,12 @@ func (i *CSIDriver) ToCSIDriverOutputWithContext(ctx context.Context) CSIDriverO return pulumi.ToOutputWithContext(ctx, i).(CSIDriverOutput) } +func (i *CSIDriver) ToOutput(ctx context.Context) pulumix.Output[*CSIDriver] { + return pulumix.Output[*CSIDriver]{ + OutputState: i.ToCSIDriverOutputWithContext(ctx).OutputState, + } +} + // CSIDriverArrayInput is an input type that accepts CSIDriverArray and CSIDriverArrayOutput values. // You can construct a concrete instance of `CSIDriverArrayInput` via: // @@ -148,6 +155,12 @@ func (i CSIDriverArray) ToCSIDriverArrayOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CSIDriverArrayOutput) } +func (i CSIDriverArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriver] { + return pulumix.Output[[]*CSIDriver]{ + OutputState: i.ToCSIDriverArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriverMapInput is an input type that accepts CSIDriverMap and CSIDriverMapOutput values. // You can construct a concrete instance of `CSIDriverMapInput` via: // @@ -173,6 +186,12 @@ func (i CSIDriverMap) ToCSIDriverMapOutputWithContext(ctx context.Context) CSIDr return pulumi.ToOutputWithContext(ctx, i).(CSIDriverMapOutput) } +func (i CSIDriverMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriver] { + return pulumix.Output[map[string]*CSIDriver]{ + OutputState: i.ToCSIDriverMapOutputWithContext(ctx).OutputState, + } +} + type CSIDriverOutput struct{ *pulumi.OutputState } func (CSIDriverOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o CSIDriverOutput) ToCSIDriverOutputWithContext(ctx context.Context) CSIDr return o } +func (o CSIDriverOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriver] { + return pulumix.Output[*CSIDriver]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIDriver) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -221,6 +246,12 @@ func (o CSIDriverArrayOutput) ToCSIDriverArrayOutputWithContext(ctx context.Cont return o } +func (o CSIDriverArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriver] { + return pulumix.Output[[]*CSIDriver]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverArrayOutput) Index(i pulumi.IntInput) CSIDriverOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIDriver { return vs[0].([]*CSIDriver)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o CSIDriverMapOutput) ToCSIDriverMapOutputWithContext(ctx context.Context) return o } +func (o CSIDriverMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriver] { + return pulumix.Output[map[string]*CSIDriver]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverMapOutput) MapIndex(k pulumi.StringInput) CSIDriverOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIDriver { return vs[0].(map[string]*CSIDriver)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csidriverList.go b/sdk/go/kubernetes/storage/v1/csidriverList.go index d5ffc192ae..3fcf7c2354 100644 --- a/sdk/go/kubernetes/storage/v1/csidriverList.go +++ b/sdk/go/kubernetes/storage/v1/csidriverList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIDriverList is a collection of CSIDriver objects. @@ -117,6 +118,12 @@ func (i *CSIDriverList) ToCSIDriverListOutputWithContext(ctx context.Context) CS return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListOutput) } +func (i *CSIDriverList) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverList] { + return pulumix.Output[*CSIDriverList]{ + OutputState: i.ToCSIDriverListOutputWithContext(ctx).OutputState, + } +} + // CSIDriverListArrayInput is an input type that accepts CSIDriverListArray and CSIDriverListArrayOutput values. // You can construct a concrete instance of `CSIDriverListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CSIDriverListArray) ToCSIDriverListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListArrayOutput) } +func (i CSIDriverListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverList] { + return pulumix.Output[[]*CSIDriverList]{ + OutputState: i.ToCSIDriverListArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriverListMapInput is an input type that accepts CSIDriverListMap and CSIDriverListMapOutput values. // You can construct a concrete instance of `CSIDriverListMapInput` via: // @@ -167,6 +180,12 @@ func (i CSIDriverListMap) ToCSIDriverListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListMapOutput) } +func (i CSIDriverListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverList] { + return pulumix.Output[map[string]*CSIDriverList]{ + OutputState: i.ToCSIDriverListMapOutputWithContext(ctx).OutputState, + } +} + type CSIDriverListOutput struct{ *pulumi.OutputState } func (CSIDriverListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CSIDriverListOutput) ToCSIDriverListOutputWithContext(ctx context.Contex return o } +func (o CSIDriverListOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverList] { + return pulumix.Output[*CSIDriverList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIDriverList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CSIDriverListArrayOutput) ToCSIDriverListArrayOutputWithContext(ctx cont return o } +func (o CSIDriverListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverList] { + return pulumix.Output[[]*CSIDriverList]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverListArrayOutput) Index(i pulumi.IntInput) CSIDriverListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIDriverList { return vs[0].([]*CSIDriverList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CSIDriverListMapOutput) ToCSIDriverListMapOutputWithContext(ctx context. return o } +func (o CSIDriverListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverList] { + return pulumix.Output[map[string]*CSIDriverList]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverListMapOutput) MapIndex(k pulumi.StringInput) CSIDriverListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIDriverList { return vs[0].(map[string]*CSIDriverList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csidriverPatch.go b/sdk/go/kubernetes/storage/v1/csidriverPatch.go index c76b9d6af3..7bd984544c 100644 --- a/sdk/go/kubernetes/storage/v1/csidriverPatch.go +++ b/sdk/go/kubernetes/storage/v1/csidriverPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *CSIDriverPatch) ToCSIDriverPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchOutput) } +func (i *CSIDriverPatch) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverPatch] { + return pulumix.Output[*CSIDriverPatch]{ + OutputState: i.ToCSIDriverPatchOutputWithContext(ctx).OutputState, + } +} + // CSIDriverPatchArrayInput is an input type that accepts CSIDriverPatchArray and CSIDriverPatchArrayOutput values. // You can construct a concrete instance of `CSIDriverPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i CSIDriverPatchArray) ToCSIDriverPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchArrayOutput) } +func (i CSIDriverPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverPatch] { + return pulumix.Output[[]*CSIDriverPatch]{ + OutputState: i.ToCSIDriverPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriverPatchMapInput is an input type that accepts CSIDriverPatchMap and CSIDriverPatchMapOutput values. // You can construct a concrete instance of `CSIDriverPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i CSIDriverPatchMap) ToCSIDriverPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchMapOutput) } +func (i CSIDriverPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverPatch] { + return pulumix.Output[map[string]*CSIDriverPatch]{ + OutputState: i.ToCSIDriverPatchMapOutputWithContext(ctx).OutputState, + } +} + type CSIDriverPatchOutput struct{ *pulumi.OutputState } func (CSIDriverPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o CSIDriverPatchOutput) ToCSIDriverPatchOutputWithContext(ctx context.Cont return o } +func (o CSIDriverPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverPatch] { + return pulumix.Output[*CSIDriverPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CSIDriverPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o CSIDriverPatchArrayOutput) ToCSIDriverPatchArrayOutputWithContext(ctx co return o } +func (o CSIDriverPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverPatch] { + return pulumix.Output[[]*CSIDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverPatchArrayOutput) Index(i pulumi.IntInput) CSIDriverPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIDriverPatch { return vs[0].([]*CSIDriverPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o CSIDriverPatchMapOutput) ToCSIDriverPatchMapOutputWithContext(ctx contex return o } +func (o CSIDriverPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverPatch] { + return pulumix.Output[map[string]*CSIDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverPatchMapOutput) MapIndex(k pulumi.StringInput) CSIDriverPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIDriverPatch { return vs[0].(map[string]*CSIDriverPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csinode.go b/sdk/go/kubernetes/storage/v1/csinode.go index b65872217a..479681f226 100644 --- a/sdk/go/kubernetes/storage/v1/csinode.go +++ b/sdk/go/kubernetes/storage/v1/csinode.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. @@ -123,6 +124,12 @@ func (i *CSINode) ToCSINodeOutputWithContext(ctx context.Context) CSINodeOutput return pulumi.ToOutputWithContext(ctx, i).(CSINodeOutput) } +func (i *CSINode) ToOutput(ctx context.Context) pulumix.Output[*CSINode] { + return pulumix.Output[*CSINode]{ + OutputState: i.ToCSINodeOutputWithContext(ctx).OutputState, + } +} + // CSINodeArrayInput is an input type that accepts CSINodeArray and CSINodeArrayOutput values. // You can construct a concrete instance of `CSINodeArrayInput` via: // @@ -148,6 +155,12 @@ func (i CSINodeArray) ToCSINodeArrayOutputWithContext(ctx context.Context) CSINo return pulumi.ToOutputWithContext(ctx, i).(CSINodeArrayOutput) } +func (i CSINodeArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSINode] { + return pulumix.Output[[]*CSINode]{ + OutputState: i.ToCSINodeArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeMapInput is an input type that accepts CSINodeMap and CSINodeMapOutput values. // You can construct a concrete instance of `CSINodeMapInput` via: // @@ -173,6 +186,12 @@ func (i CSINodeMap) ToCSINodeMapOutputWithContext(ctx context.Context) CSINodeMa return pulumi.ToOutputWithContext(ctx, i).(CSINodeMapOutput) } +func (i CSINodeMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINode] { + return pulumix.Output[map[string]*CSINode]{ + OutputState: i.ToCSINodeMapOutputWithContext(ctx).OutputState, + } +} + type CSINodeOutput struct{ *pulumi.OutputState } func (CSINodeOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o CSINodeOutput) ToCSINodeOutputWithContext(ctx context.Context) CSINodeOu return o } +func (o CSINodeOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINode] { + return pulumix.Output[*CSINode]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSINode) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -221,6 +246,12 @@ func (o CSINodeArrayOutput) ToCSINodeArrayOutputWithContext(ctx context.Context) return o } +func (o CSINodeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSINode] { + return pulumix.Output[[]*CSINode]{ + OutputState: o.OutputState, + } +} + func (o CSINodeArrayOutput) Index(i pulumi.IntInput) CSINodeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSINode { return vs[0].([]*CSINode)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o CSINodeMapOutput) ToCSINodeMapOutputWithContext(ctx context.Context) CSI return o } +func (o CSINodeMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINode] { + return pulumix.Output[map[string]*CSINode]{ + OutputState: o.OutputState, + } +} + func (o CSINodeMapOutput) MapIndex(k pulumi.StringInput) CSINodeOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSINode { return vs[0].(map[string]*CSINode)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csinodeList.go b/sdk/go/kubernetes/storage/v1/csinodeList.go index 11d4ad2225..bb2eb4c314 100644 --- a/sdk/go/kubernetes/storage/v1/csinodeList.go +++ b/sdk/go/kubernetes/storage/v1/csinodeList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSINodeList is a collection of CSINode objects. @@ -117,6 +118,12 @@ func (i *CSINodeList) ToCSINodeListOutputWithContext(ctx context.Context) CSINod return pulumi.ToOutputWithContext(ctx, i).(CSINodeListOutput) } +func (i *CSINodeList) ToOutput(ctx context.Context) pulumix.Output[*CSINodeList] { + return pulumix.Output[*CSINodeList]{ + OutputState: i.ToCSINodeListOutputWithContext(ctx).OutputState, + } +} + // CSINodeListArrayInput is an input type that accepts CSINodeListArray and CSINodeListArrayOutput values. // You can construct a concrete instance of `CSINodeListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CSINodeListArray) ToCSINodeListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CSINodeListArrayOutput) } +func (i CSINodeListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodeList] { + return pulumix.Output[[]*CSINodeList]{ + OutputState: i.ToCSINodeListArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeListMapInput is an input type that accepts CSINodeListMap and CSINodeListMapOutput values. // You can construct a concrete instance of `CSINodeListMapInput` via: // @@ -167,6 +180,12 @@ func (i CSINodeListMap) ToCSINodeListMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CSINodeListMapOutput) } +func (i CSINodeListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodeList] { + return pulumix.Output[map[string]*CSINodeList]{ + OutputState: i.ToCSINodeListMapOutputWithContext(ctx).OutputState, + } +} + type CSINodeListOutput struct{ *pulumi.OutputState } func (CSINodeListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CSINodeListOutput) ToCSINodeListOutputWithContext(ctx context.Context) C return o } +func (o CSINodeListOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINodeList] { + return pulumix.Output[*CSINodeList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSINodeList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CSINodeListArrayOutput) ToCSINodeListArrayOutputWithContext(ctx context. return o } +func (o CSINodeListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodeList] { + return pulumix.Output[[]*CSINodeList]{ + OutputState: o.OutputState, + } +} + func (o CSINodeListArrayOutput) Index(i pulumi.IntInput) CSINodeListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSINodeList { return vs[0].([]*CSINodeList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CSINodeListMapOutput) ToCSINodeListMapOutputWithContext(ctx context.Cont return o } +func (o CSINodeListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodeList] { + return pulumix.Output[map[string]*CSINodeList]{ + OutputState: o.OutputState, + } +} + func (o CSINodeListMapOutput) MapIndex(k pulumi.StringInput) CSINodeListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSINodeList { return vs[0].(map[string]*CSINodeList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csinodePatch.go b/sdk/go/kubernetes/storage/v1/csinodePatch.go index 7d6f6b865a..8a3905cada 100644 --- a/sdk/go/kubernetes/storage/v1/csinodePatch.go +++ b/sdk/go/kubernetes/storage/v1/csinodePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *CSINodePatch) ToCSINodePatchOutputWithContext(ctx context.Context) CSIN return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchOutput) } +func (i *CSINodePatch) ToOutput(ctx context.Context) pulumix.Output[*CSINodePatch] { + return pulumix.Output[*CSINodePatch]{ + OutputState: i.ToCSINodePatchOutputWithContext(ctx).OutputState, + } +} + // CSINodePatchArrayInput is an input type that accepts CSINodePatchArray and CSINodePatchArrayOutput values. // You can construct a concrete instance of `CSINodePatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i CSINodePatchArray) ToCSINodePatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchArrayOutput) } +func (i CSINodePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodePatch] { + return pulumix.Output[[]*CSINodePatch]{ + OutputState: i.ToCSINodePatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodePatchMapInput is an input type that accepts CSINodePatchMap and CSINodePatchMapOutput values. // You can construct a concrete instance of `CSINodePatchMapInput` via: // @@ -175,6 +188,12 @@ func (i CSINodePatchMap) ToCSINodePatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchMapOutput) } +func (i CSINodePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodePatch] { + return pulumix.Output[map[string]*CSINodePatch]{ + OutputState: i.ToCSINodePatchMapOutputWithContext(ctx).OutputState, + } +} + type CSINodePatchOutput struct{ *pulumi.OutputState } func (CSINodePatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o CSINodePatchOutput) ToCSINodePatchOutputWithContext(ctx context.Context) return o } +func (o CSINodePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINodePatch] { + return pulumix.Output[*CSINodePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CSINodePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o CSINodePatchArrayOutput) ToCSINodePatchArrayOutputWithContext(ctx contex return o } +func (o CSINodePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodePatch] { + return pulumix.Output[[]*CSINodePatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodePatchArrayOutput) Index(i pulumi.IntInput) CSINodePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSINodePatch { return vs[0].([]*CSINodePatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o CSINodePatchMapOutput) ToCSINodePatchMapOutputWithContext(ctx context.Co return o } +func (o CSINodePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodePatch] { + return pulumix.Output[map[string]*CSINodePatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodePatchMapOutput) MapIndex(k pulumi.StringInput) CSINodePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSINodePatch { return vs[0].(map[string]*CSINodePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csistorageCapacity.go b/sdk/go/kubernetes/storage/v1/csistorageCapacity.go index f04b2ee579..2aed0d317f 100644 --- a/sdk/go/kubernetes/storage/v1/csistorageCapacity.go +++ b/sdk/go/kubernetes/storage/v1/csistorageCapacity.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. @@ -176,6 +177,12 @@ func (i *CSIStorageCapacity) ToCSIStorageCapacityOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityOutput) } +func (i *CSIStorageCapacity) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacity] { + return pulumix.Output[*CSIStorageCapacity]{ + OutputState: i.ToCSIStorageCapacityOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityArrayInput is an input type that accepts CSIStorageCapacityArray and CSIStorageCapacityArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityArrayInput` via: // @@ -201,6 +208,12 @@ func (i CSIStorageCapacityArray) ToCSIStorageCapacityArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityArrayOutput) } +func (i CSIStorageCapacityArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacity] { + return pulumix.Output[[]*CSIStorageCapacity]{ + OutputState: i.ToCSIStorageCapacityArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityMapInput is an input type that accepts CSIStorageCapacityMap and CSIStorageCapacityMapOutput values. // You can construct a concrete instance of `CSIStorageCapacityMapInput` via: // @@ -226,6 +239,12 @@ func (i CSIStorageCapacityMap) ToCSIStorageCapacityMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityMapOutput) } +func (i CSIStorageCapacityMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacity] { + return pulumix.Output[map[string]*CSIStorageCapacity]{ + OutputState: i.ToCSIStorageCapacityMapOutputWithContext(ctx).OutputState, + } +} + type CSIStorageCapacityOutput struct{ *pulumi.OutputState } func (CSIStorageCapacityOutput) ElementType() reflect.Type { @@ -240,6 +259,12 @@ func (o CSIStorageCapacityOutput) ToCSIStorageCapacityOutputWithContext(ctx cont return o } +func (o CSIStorageCapacityOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacity] { + return pulumix.Output[*CSIStorageCapacity]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIStorageCapacity) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -297,6 +322,12 @@ func (o CSIStorageCapacityArrayOutput) ToCSIStorageCapacityArrayOutputWithContex return o } +func (o CSIStorageCapacityArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacity] { + return pulumix.Output[[]*CSIStorageCapacity]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIStorageCapacity { return vs[0].([]*CSIStorageCapacity)[vs[1].(int)] @@ -317,6 +348,12 @@ func (o CSIStorageCapacityMapOutput) ToCSIStorageCapacityMapOutputWithContext(ct return o } +func (o CSIStorageCapacityMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacity] { + return pulumix.Output[map[string]*CSIStorageCapacity]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityMapOutput) MapIndex(k pulumi.StringInput) CSIStorageCapacityOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIStorageCapacity { return vs[0].(map[string]*CSIStorageCapacity)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csistorageCapacityList.go b/sdk/go/kubernetes/storage/v1/csistorageCapacityList.go index fecc4bb437..5175a8de79 100644 --- a/sdk/go/kubernetes/storage/v1/csistorageCapacityList.go +++ b/sdk/go/kubernetes/storage/v1/csistorageCapacityList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIStorageCapacityList is a collection of CSIStorageCapacity objects. @@ -117,6 +118,12 @@ func (i *CSIStorageCapacityList) ToCSIStorageCapacityListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListOutput) } +func (i *CSIStorageCapacityList) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityList] { + return pulumix.Output[*CSIStorageCapacityList]{ + OutputState: i.ToCSIStorageCapacityListOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityListArrayInput is an input type that accepts CSIStorageCapacityListArray and CSIStorageCapacityListArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CSIStorageCapacityListArray) ToCSIStorageCapacityListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListArrayOutput) } +func (i CSIStorageCapacityListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityList] { + return pulumix.Output[[]*CSIStorageCapacityList]{ + OutputState: i.ToCSIStorageCapacityListArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityListMapInput is an input type that accepts CSIStorageCapacityListMap and CSIStorageCapacityListMapOutput values. // You can construct a concrete instance of `CSIStorageCapacityListMapInput` via: // @@ -167,6 +180,12 @@ func (i CSIStorageCapacityListMap) ToCSIStorageCapacityListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListMapOutput) } +func (i CSIStorageCapacityListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityList] { + return pulumix.Output[map[string]*CSIStorageCapacityList]{ + OutputState: i.ToCSIStorageCapacityListMapOutputWithContext(ctx).OutputState, + } +} + type CSIStorageCapacityListOutput struct{ *pulumi.OutputState } func (CSIStorageCapacityListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CSIStorageCapacityListOutput) ToCSIStorageCapacityListOutputWithContext( return o } +func (o CSIStorageCapacityListOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityList] { + return pulumix.Output[*CSIStorageCapacityList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIStorageCapacityList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CSIStorageCapacityListArrayOutput) ToCSIStorageCapacityListArrayOutputWi return o } +func (o CSIStorageCapacityListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityList] { + return pulumix.Output[[]*CSIStorageCapacityList]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityListArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIStorageCapacityList { return vs[0].([]*CSIStorageCapacityList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CSIStorageCapacityListMapOutput) ToCSIStorageCapacityListMapOutputWithCo return o } +func (o CSIStorageCapacityListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityList] { + return pulumix.Output[map[string]*CSIStorageCapacityList]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityListMapOutput) MapIndex(k pulumi.StringInput) CSIStorageCapacityListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIStorageCapacityList { return vs[0].(map[string]*CSIStorageCapacityList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/csistorageCapacityPatch.go b/sdk/go/kubernetes/storage/v1/csistorageCapacityPatch.go index 56a6b259ec..adf57cd13e 100644 --- a/sdk/go/kubernetes/storage/v1/csistorageCapacityPatch.go +++ b/sdk/go/kubernetes/storage/v1/csistorageCapacityPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -178,6 +179,12 @@ func (i *CSIStorageCapacityPatch) ToCSIStorageCapacityPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchOutput) } +func (i *CSIStorageCapacityPatch) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityPatch] { + return pulumix.Output[*CSIStorageCapacityPatch]{ + OutputState: i.ToCSIStorageCapacityPatchOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityPatchArrayInput is an input type that accepts CSIStorageCapacityPatchArray and CSIStorageCapacityPatchArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityPatchArrayInput` via: // @@ -203,6 +210,12 @@ func (i CSIStorageCapacityPatchArray) ToCSIStorageCapacityPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchArrayOutput) } +func (i CSIStorageCapacityPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityPatch] { + return pulumix.Output[[]*CSIStorageCapacityPatch]{ + OutputState: i.ToCSIStorageCapacityPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityPatchMapInput is an input type that accepts CSIStorageCapacityPatchMap and CSIStorageCapacityPatchMapOutput values. // You can construct a concrete instance of `CSIStorageCapacityPatchMapInput` via: // @@ -228,6 +241,12 @@ func (i CSIStorageCapacityPatchMap) ToCSIStorageCapacityPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchMapOutput) } +func (i CSIStorageCapacityPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityPatch] { + return pulumix.Output[map[string]*CSIStorageCapacityPatch]{ + OutputState: i.ToCSIStorageCapacityPatchMapOutputWithContext(ctx).OutputState, + } +} + type CSIStorageCapacityPatchOutput struct{ *pulumi.OutputState } func (CSIStorageCapacityPatchOutput) ElementType() reflect.Type { @@ -242,6 +261,12 @@ func (o CSIStorageCapacityPatchOutput) ToCSIStorageCapacityPatchOutputWithContex return o } +func (o CSIStorageCapacityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityPatch] { + return pulumix.Output[*CSIStorageCapacityPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CSIStorageCapacityPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -299,6 +324,12 @@ func (o CSIStorageCapacityPatchArrayOutput) ToCSIStorageCapacityPatchArrayOutput return o } +func (o CSIStorageCapacityPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityPatch] { + return pulumix.Output[[]*CSIStorageCapacityPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityPatchArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIStorageCapacityPatch { return vs[0].([]*CSIStorageCapacityPatch)[vs[1].(int)] @@ -319,6 +350,12 @@ func (o CSIStorageCapacityPatchMapOutput) ToCSIStorageCapacityPatchMapOutputWith return o } +func (o CSIStorageCapacityPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityPatch] { + return pulumix.Output[map[string]*CSIStorageCapacityPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityPatchMapOutput) MapIndex(k pulumi.StringInput) CSIStorageCapacityPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIStorageCapacityPatch { return vs[0].(map[string]*CSIStorageCapacityPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/pulumiTypes.go b/sdk/go/kubernetes/storage/v1/pulumiTypes.go index 342c7ce463..9d6f8b567f 100644 --- a/sdk/go/kubernetes/storage/v1/pulumiTypes.go +++ b/sdk/go/kubernetes/storage/v1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -62,6 +63,12 @@ func (i CSIDriverTypeArgs) ToCSIDriverTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSIDriverTypeOutput) } +func (i CSIDriverTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverType] { + return pulumix.Output[CSIDriverType]{ + OutputState: i.ToCSIDriverTypeOutputWithContext(ctx).OutputState, + } +} + // CSIDriverTypeArrayInput is an input type that accepts CSIDriverTypeArray and CSIDriverTypeArrayOutput values. // You can construct a concrete instance of `CSIDriverTypeArrayInput` via: // @@ -87,6 +94,12 @@ func (i CSIDriverTypeArray) ToCSIDriverTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSIDriverTypeArrayOutput) } +func (i CSIDriverTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CSIDriverType] { + return pulumix.Output[[]CSIDriverType]{ + OutputState: i.ToCSIDriverTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. type CSIDriverTypeOutput struct{ *pulumi.OutputState } @@ -102,6 +115,12 @@ func (o CSIDriverTypeOutput) ToCSIDriverTypeOutputWithContext(ctx context.Contex return o } +func (o CSIDriverTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverType] { + return pulumix.Output[CSIDriverType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIDriverType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -136,6 +155,12 @@ func (o CSIDriverTypeArrayOutput) ToCSIDriverTypeArrayOutputWithContext(ctx cont return o } +func (o CSIDriverTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSIDriverType] { + return pulumix.Output[[]CSIDriverType]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverTypeArrayOutput) Index(i pulumi.IntInput) CSIDriverTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSIDriverType { return vs[0].([]CSIDriverType)[vs[1].(int)] @@ -189,6 +214,12 @@ func (i CSIDriverListTypeArgs) ToCSIDriverListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListTypeOutput) } +func (i CSIDriverListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverListType] { + return pulumix.Output[CSIDriverListType]{ + OutputState: i.ToCSIDriverListTypeOutputWithContext(ctx).OutputState, + } +} + // CSIDriverList is a collection of CSIDriver objects. type CSIDriverListTypeOutput struct{ *pulumi.OutputState } @@ -204,6 +235,12 @@ func (o CSIDriverListTypeOutput) ToCSIDriverListTypeOutputWithContext(ctx contex return o } +func (o CSIDriverListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverListType] { + return pulumix.Output[CSIDriverListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIDriverListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -271,6 +308,12 @@ func (i CSIDriverPatchTypeArgs) ToCSIDriverPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchTypeOutput) } +func (i CSIDriverPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverPatchType] { + return pulumix.Output[CSIDriverPatchType]{ + OutputState: i.ToCSIDriverPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. type CSIDriverPatchTypeOutput struct{ *pulumi.OutputState } @@ -286,6 +329,12 @@ func (o CSIDriverPatchTypeOutput) ToCSIDriverPatchTypeOutputWithContext(ctx cont return o } +func (o CSIDriverPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverPatchType] { + return pulumix.Output[CSIDriverPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIDriverPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -455,6 +504,12 @@ func (i CSIDriverSpecArgs) ToCSIDriverSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSIDriverSpecOutput) } +func (i CSIDriverSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpec] { + return pulumix.Output[CSIDriverSpec]{ + OutputState: i.ToCSIDriverSpecOutputWithContext(ctx).OutputState, + } +} + // CSIDriverSpec is the specification of a CSIDriver. type CSIDriverSpecOutput struct{ *pulumi.OutputState } @@ -470,6 +525,12 @@ func (o CSIDriverSpecOutput) ToCSIDriverSpecOutputWithContext(ctx context.Contex return o } +func (o CSIDriverSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpec] { + return pulumix.Output[CSIDriverSpec]{ + OutputState: o.OutputState, + } +} + // attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called. // // This field is immutable. @@ -703,6 +764,12 @@ func (i CSIDriverSpecPatchArgs) ToCSIDriverSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CSIDriverSpecPatchOutput) } +func (i CSIDriverSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpecPatch] { + return pulumix.Output[CSIDriverSpecPatch]{ + OutputState: i.ToCSIDriverSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CSIDriverSpecPatchArgs) ToCSIDriverSpecPatchPtrOutput() CSIDriverSpecPatchPtrOutput { return i.ToCSIDriverSpecPatchPtrOutputWithContext(context.Background()) } @@ -744,6 +811,12 @@ func (i *csidriverSpecPatchPtrType) ToCSIDriverSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSIDriverSpecPatchPtrOutput) } +func (i *csidriverSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverSpecPatch] { + return pulumix.Output[*CSIDriverSpecPatch]{ + OutputState: i.ToCSIDriverSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CSIDriverSpec is the specification of a CSIDriver. type CSIDriverSpecPatchOutput struct{ *pulumi.OutputState } @@ -769,6 +842,12 @@ func (o CSIDriverSpecPatchOutput) ToCSIDriverSpecPatchPtrOutputWithContext(ctx c }).(CSIDriverSpecPatchPtrOutput) } +func (o CSIDriverSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpecPatch] { + return pulumix.Output[CSIDriverSpecPatch]{ + OutputState: o.OutputState, + } +} + // attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called. // // This field is immutable. @@ -867,6 +946,12 @@ func (o CSIDriverSpecPatchPtrOutput) ToCSIDriverSpecPatchPtrOutputWithContext(ct return o } +func (o CSIDriverSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverSpecPatch] { + return pulumix.Output[*CSIDriverSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverSpecPatchPtrOutput) Elem() CSIDriverSpecPatchOutput { return o.ApplyT(func(v *CSIDriverSpecPatch) CSIDriverSpecPatch { if v != nil { @@ -1048,6 +1133,12 @@ func (i CSINodeTypeArgs) ToCSINodeTypeOutputWithContext(ctx context.Context) CSI return pulumi.ToOutputWithContext(ctx, i).(CSINodeTypeOutput) } +func (i CSINodeTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeType] { + return pulumix.Output[CSINodeType]{ + OutputState: i.ToCSINodeTypeOutputWithContext(ctx).OutputState, + } +} + // CSINodeTypeArrayInput is an input type that accepts CSINodeTypeArray and CSINodeTypeArrayOutput values. // You can construct a concrete instance of `CSINodeTypeArrayInput` via: // @@ -1073,6 +1164,12 @@ func (i CSINodeTypeArray) ToCSINodeTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CSINodeTypeArrayOutput) } +func (i CSINodeTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeType] { + return pulumix.Output[[]CSINodeType]{ + OutputState: i.ToCSINodeTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. type CSINodeTypeOutput struct{ *pulumi.OutputState } @@ -1088,6 +1185,12 @@ func (o CSINodeTypeOutput) ToCSINodeTypeOutputWithContext(ctx context.Context) C return o } +func (o CSINodeTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeType] { + return pulumix.Output[CSINodeType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSINodeType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1122,6 +1225,12 @@ func (o CSINodeTypeArrayOutput) ToCSINodeTypeArrayOutputWithContext(ctx context. return o } +func (o CSINodeTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeType] { + return pulumix.Output[[]CSINodeType]{ + OutputState: o.OutputState, + } +} + func (o CSINodeTypeArrayOutput) Index(i pulumi.IntInput) CSINodeTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSINodeType { return vs[0].([]CSINodeType)[vs[1].(int)] @@ -1175,6 +1284,12 @@ func (i CSINodeDriverArgs) ToCSINodeDriverOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverOutput) } +func (i CSINodeDriverArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriver] { + return pulumix.Output[CSINodeDriver]{ + OutputState: i.ToCSINodeDriverOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriverArrayInput is an input type that accepts CSINodeDriverArray and CSINodeDriverArrayOutput values. // You can construct a concrete instance of `CSINodeDriverArrayInput` via: // @@ -1200,6 +1315,12 @@ func (i CSINodeDriverArray) ToCSINodeDriverArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverArrayOutput) } +func (i CSINodeDriverArray) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriver] { + return pulumix.Output[[]CSINodeDriver]{ + OutputState: i.ToCSINodeDriverArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriver holds information about the specification of one CSI driver installed on a node type CSINodeDriverOutput struct{ *pulumi.OutputState } @@ -1215,6 +1336,12 @@ func (o CSINodeDriverOutput) ToCSINodeDriverOutputWithContext(ctx context.Contex return o } +func (o CSINodeDriverOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriver] { + return pulumix.Output[CSINodeDriver]{ + OutputState: o.OutputState, + } +} + // allocatable represents the volume resources of a node that are available for scheduling. This field is beta. func (o CSINodeDriverOutput) Allocatable() VolumeNodeResourcesPtrOutput { return o.ApplyT(func(v CSINodeDriver) *VolumeNodeResources { return v.Allocatable }).(VolumeNodeResourcesPtrOutput) @@ -1249,6 +1376,12 @@ func (o CSINodeDriverArrayOutput) ToCSINodeDriverArrayOutputWithContext(ctx cont return o } +func (o CSINodeDriverArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriver] { + return pulumix.Output[[]CSINodeDriver]{ + OutputState: o.OutputState, + } +} + func (o CSINodeDriverArrayOutput) Index(i pulumi.IntInput) CSINodeDriverOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSINodeDriver { return vs[0].([]CSINodeDriver)[vs[1].(int)] @@ -1302,6 +1435,12 @@ func (i CSINodeDriverPatchArgs) ToCSINodeDriverPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverPatchOutput) } +func (i CSINodeDriverPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriverPatch] { + return pulumix.Output[CSINodeDriverPatch]{ + OutputState: i.ToCSINodeDriverPatchOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriverPatchArrayInput is an input type that accepts CSINodeDriverPatchArray and CSINodeDriverPatchArrayOutput values. // You can construct a concrete instance of `CSINodeDriverPatchArrayInput` via: // @@ -1327,6 +1466,12 @@ func (i CSINodeDriverPatchArray) ToCSINodeDriverPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverPatchArrayOutput) } +func (i CSINodeDriverPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriverPatch] { + return pulumix.Output[[]CSINodeDriverPatch]{ + OutputState: i.ToCSINodeDriverPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriver holds information about the specification of one CSI driver installed on a node type CSINodeDriverPatchOutput struct{ *pulumi.OutputState } @@ -1342,6 +1487,12 @@ func (o CSINodeDriverPatchOutput) ToCSINodeDriverPatchOutputWithContext(ctx cont return o } +func (o CSINodeDriverPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriverPatch] { + return pulumix.Output[CSINodeDriverPatch]{ + OutputState: o.OutputState, + } +} + // allocatable represents the volume resources of a node that are available for scheduling. This field is beta. func (o CSINodeDriverPatchOutput) Allocatable() VolumeNodeResourcesPatchPtrOutput { return o.ApplyT(func(v CSINodeDriverPatch) *VolumeNodeResourcesPatch { return v.Allocatable }).(VolumeNodeResourcesPatchPtrOutput) @@ -1376,6 +1527,12 @@ func (o CSINodeDriverPatchArrayOutput) ToCSINodeDriverPatchArrayOutputWithContex return o } +func (o CSINodeDriverPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriverPatch] { + return pulumix.Output[[]CSINodeDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodeDriverPatchArrayOutput) Index(i pulumi.IntInput) CSINodeDriverPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSINodeDriverPatch { return vs[0].([]CSINodeDriverPatch)[vs[1].(int)] @@ -1429,6 +1586,12 @@ func (i CSINodeListTypeArgs) ToCSINodeListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSINodeListTypeOutput) } +func (i CSINodeListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeListType] { + return pulumix.Output[CSINodeListType]{ + OutputState: i.ToCSINodeListTypeOutputWithContext(ctx).OutputState, + } +} + // CSINodeList is a collection of CSINode objects. type CSINodeListTypeOutput struct{ *pulumi.OutputState } @@ -1444,6 +1607,12 @@ func (o CSINodeListTypeOutput) ToCSINodeListTypeOutputWithContext(ctx context.Co return o } +func (o CSINodeListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeListType] { + return pulumix.Output[CSINodeListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSINodeListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1511,6 +1680,12 @@ func (i CSINodePatchTypeArgs) ToCSINodePatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchTypeOutput) } +func (i CSINodePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodePatchType] { + return pulumix.Output[CSINodePatchType]{ + OutputState: i.ToCSINodePatchTypeOutputWithContext(ctx).OutputState, + } +} + // CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. type CSINodePatchTypeOutput struct{ *pulumi.OutputState } @@ -1526,6 +1701,12 @@ func (o CSINodePatchTypeOutput) ToCSINodePatchTypeOutputWithContext(ctx context. return o } +func (o CSINodePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodePatchType] { + return pulumix.Output[CSINodePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSINodePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1581,6 +1762,12 @@ func (i CSINodeSpecArgs) ToCSINodeSpecOutputWithContext(ctx context.Context) CSI return pulumi.ToOutputWithContext(ctx, i).(CSINodeSpecOutput) } +func (i CSINodeSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpec] { + return pulumix.Output[CSINodeSpec]{ + OutputState: i.ToCSINodeSpecOutputWithContext(ctx).OutputState, + } +} + // CSINodeSpec holds information about the specification of all CSI drivers installed on a node type CSINodeSpecOutput struct{ *pulumi.OutputState } @@ -1596,6 +1783,12 @@ func (o CSINodeSpecOutput) ToCSINodeSpecOutputWithContext(ctx context.Context) C return o } +func (o CSINodeSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpec] { + return pulumix.Output[CSINodeSpec]{ + OutputState: o.OutputState, + } +} + // drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. func (o CSINodeSpecOutput) Drivers() CSINodeDriverArrayOutput { return o.ApplyT(func(v CSINodeSpec) []CSINodeDriver { return v.Drivers }).(CSINodeDriverArrayOutput) @@ -1636,6 +1829,12 @@ func (i CSINodeSpecPatchArgs) ToCSINodeSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSINodeSpecPatchOutput) } +func (i CSINodeSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpecPatch] { + return pulumix.Output[CSINodeSpecPatch]{ + OutputState: i.ToCSINodeSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CSINodeSpecPatchArgs) ToCSINodeSpecPatchPtrOutput() CSINodeSpecPatchPtrOutput { return i.ToCSINodeSpecPatchPtrOutputWithContext(context.Background()) } @@ -1677,6 +1876,12 @@ func (i *csinodeSpecPatchPtrType) ToCSINodeSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(CSINodeSpecPatchPtrOutput) } +func (i *csinodeSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CSINodeSpecPatch] { + return pulumix.Output[*CSINodeSpecPatch]{ + OutputState: i.ToCSINodeSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CSINodeSpec holds information about the specification of all CSI drivers installed on a node type CSINodeSpecPatchOutput struct{ *pulumi.OutputState } @@ -1702,6 +1907,12 @@ func (o CSINodeSpecPatchOutput) ToCSINodeSpecPatchPtrOutputWithContext(ctx conte }).(CSINodeSpecPatchPtrOutput) } +func (o CSINodeSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpecPatch] { + return pulumix.Output[CSINodeSpecPatch]{ + OutputState: o.OutputState, + } +} + // drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. func (o CSINodeSpecPatchOutput) Drivers() CSINodeDriverPatchArrayOutput { return o.ApplyT(func(v CSINodeSpecPatch) []CSINodeDriverPatch { return v.Drivers }).(CSINodeDriverPatchArrayOutput) @@ -1721,6 +1932,12 @@ func (o CSINodeSpecPatchPtrOutput) ToCSINodeSpecPatchPtrOutputWithContext(ctx co return o } +func (o CSINodeSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINodeSpecPatch] { + return pulumix.Output[*CSINodeSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodeSpecPatchPtrOutput) Elem() CSINodeSpecPatchOutput { return o.ApplyT(func(v *CSINodeSpecPatch) CSINodeSpecPatch { if v != nil { @@ -1832,6 +2049,12 @@ func (i CSIStorageCapacityTypeArgs) ToCSIStorageCapacityTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityTypeOutput) } +func (i CSIStorageCapacityTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityType] { + return pulumix.Output[CSIStorageCapacityType]{ + OutputState: i.ToCSIStorageCapacityTypeOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityTypeArrayInput is an input type that accepts CSIStorageCapacityTypeArray and CSIStorageCapacityTypeArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityTypeArrayInput` via: // @@ -1857,6 +2080,12 @@ func (i CSIStorageCapacityTypeArray) ToCSIStorageCapacityTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityTypeArrayOutput) } +func (i CSIStorageCapacityTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CSIStorageCapacityType] { + return pulumix.Output[[]CSIStorageCapacityType]{ + OutputState: i.ToCSIStorageCapacityTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. // // For example this can express things like: - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1" - StorageClass "localssd" has "10 GiB" available in "kubernetes.io/hostname=knode-abc123" @@ -1880,6 +2109,12 @@ func (o CSIStorageCapacityTypeOutput) ToCSIStorageCapacityTypeOutputWithContext( return o } +func (o CSIStorageCapacityTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityType] { + return pulumix.Output[CSIStorageCapacityType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIStorageCapacityType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1937,6 +2172,12 @@ func (o CSIStorageCapacityTypeArrayOutput) ToCSIStorageCapacityTypeArrayOutputWi return o } +func (o CSIStorageCapacityTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSIStorageCapacityType] { + return pulumix.Output[[]CSIStorageCapacityType]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityTypeArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSIStorageCapacityType { return vs[0].([]CSIStorageCapacityType)[vs[1].(int)] @@ -1990,6 +2231,12 @@ func (i CSIStorageCapacityListTypeArgs) ToCSIStorageCapacityListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListTypeOutput) } +func (i CSIStorageCapacityListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityListType] { + return pulumix.Output[CSIStorageCapacityListType]{ + OutputState: i.ToCSIStorageCapacityListTypeOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityList is a collection of CSIStorageCapacity objects. type CSIStorageCapacityListTypeOutput struct{ *pulumi.OutputState } @@ -2005,6 +2252,12 @@ func (o CSIStorageCapacityListTypeOutput) ToCSIStorageCapacityListTypeOutputWith return o } +func (o CSIStorageCapacityListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityListType] { + return pulumix.Output[CSIStorageCapacityListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIStorageCapacityListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2116,6 +2369,12 @@ func (i CSIStorageCapacityPatchTypeArgs) ToCSIStorageCapacityPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchTypeOutput) } +func (i CSIStorageCapacityPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityPatchType] { + return pulumix.Output[CSIStorageCapacityPatchType]{ + OutputState: i.ToCSIStorageCapacityPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. // // For example this can express things like: - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1" - StorageClass "localssd" has "10 GiB" available in "kubernetes.io/hostname=knode-abc123" @@ -2139,6 +2398,12 @@ func (o CSIStorageCapacityPatchTypeOutput) ToCSIStorageCapacityPatchTypeOutputWi return o } +func (o CSIStorageCapacityPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityPatchType] { + return pulumix.Output[CSIStorageCapacityPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIStorageCapacityPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2257,6 +2522,12 @@ func (i StorageClassTypeArgs) ToStorageClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StorageClassTypeOutput) } +func (i StorageClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StorageClassType] { + return pulumix.Output[StorageClassType]{ + OutputState: i.ToStorageClassTypeOutputWithContext(ctx).OutputState, + } +} + // StorageClassTypeArrayInput is an input type that accepts StorageClassTypeArray and StorageClassTypeArrayOutput values. // You can construct a concrete instance of `StorageClassTypeArrayInput` via: // @@ -2282,6 +2553,12 @@ func (i StorageClassTypeArray) ToStorageClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StorageClassTypeArrayOutput) } +func (i StorageClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]StorageClassType] { + return pulumix.Output[[]StorageClassType]{ + OutputState: i.ToStorageClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. // // StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. @@ -2299,6 +2576,12 @@ func (o StorageClassTypeOutput) ToStorageClassTypeOutputWithContext(ctx context. return o } +func (o StorageClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StorageClassType] { + return pulumix.Output[StorageClassType]{ + OutputState: o.OutputState, + } +} + // allowVolumeExpansion shows whether the storage class allow volume expand. func (o StorageClassTypeOutput) AllowVolumeExpansion() pulumi.BoolPtrOutput { return o.ApplyT(func(v StorageClassType) *bool { return v.AllowVolumeExpansion }).(pulumi.BoolPtrOutput) @@ -2363,6 +2646,12 @@ func (o StorageClassTypeArrayOutput) ToStorageClassTypeArrayOutputWithContext(ct return o } +func (o StorageClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StorageClassType] { + return pulumix.Output[[]StorageClassType]{ + OutputState: o.OutputState, + } +} + func (o StorageClassTypeArrayOutput) Index(i pulumi.IntInput) StorageClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StorageClassType { return vs[0].([]StorageClassType)[vs[1].(int)] @@ -2416,6 +2705,12 @@ func (i StorageClassListTypeArgs) ToStorageClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StorageClassListTypeOutput) } +func (i StorageClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StorageClassListType] { + return pulumix.Output[StorageClassListType]{ + OutputState: i.ToStorageClassListTypeOutputWithContext(ctx).OutputState, + } +} + // StorageClassList is a collection of storage classes. type StorageClassListTypeOutput struct{ *pulumi.OutputState } @@ -2431,6 +2726,12 @@ func (o StorageClassListTypeOutput) ToStorageClassListTypeOutputWithContext(ctx return o } +func (o StorageClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StorageClassListType] { + return pulumix.Output[StorageClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StorageClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StorageClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2526,6 +2827,12 @@ func (i StorageClassPatchTypeArgs) ToStorageClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchTypeOutput) } +func (i StorageClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StorageClassPatchType] { + return pulumix.Output[StorageClassPatchType]{ + OutputState: i.ToStorageClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. // // StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. @@ -2543,6 +2850,12 @@ func (o StorageClassPatchTypeOutput) ToStorageClassPatchTypeOutputWithContext(ct return o } +func (o StorageClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StorageClassPatchType] { + return pulumix.Output[StorageClassPatchType]{ + OutputState: o.OutputState, + } +} + // allowVolumeExpansion shows whether the storage class allow volume expand. func (o StorageClassPatchTypeOutput) AllowVolumeExpansion() pulumi.BoolPtrOutput { return o.ApplyT(func(v StorageClassPatchType) *bool { return v.AllowVolumeExpansion }).(pulumi.BoolPtrOutput) @@ -2632,6 +2945,12 @@ func (i TokenRequestArgs) ToTokenRequestOutputWithContext(ctx context.Context) T return pulumi.ToOutputWithContext(ctx, i).(TokenRequestOutput) } +func (i TokenRequestArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequest] { + return pulumix.Output[TokenRequest]{ + OutputState: i.ToTokenRequestOutputWithContext(ctx).OutputState, + } +} + // TokenRequestArrayInput is an input type that accepts TokenRequestArray and TokenRequestArrayOutput values. // You can construct a concrete instance of `TokenRequestArrayInput` via: // @@ -2657,6 +2976,12 @@ func (i TokenRequestArray) ToTokenRequestArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(TokenRequestArrayOutput) } +func (i TokenRequestArray) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequest] { + return pulumix.Output[[]TokenRequest]{ + OutputState: i.ToTokenRequestArrayOutputWithContext(ctx).OutputState, + } +} + // TokenRequest contains parameters of a service account token. type TokenRequestOutput struct{ *pulumi.OutputState } @@ -2672,6 +2997,12 @@ func (o TokenRequestOutput) ToTokenRequestOutputWithContext(ctx context.Context) return o } +func (o TokenRequestOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequest] { + return pulumix.Output[TokenRequest]{ + OutputState: o.OutputState, + } +} + // audience is the intended audience of the token in "TokenRequestSpec". It will default to the audiences of kube apiserver. func (o TokenRequestOutput) Audience() pulumi.StringOutput { return o.ApplyT(func(v TokenRequest) string { return v.Audience }).(pulumi.StringOutput) @@ -2696,6 +3027,12 @@ func (o TokenRequestArrayOutput) ToTokenRequestArrayOutputWithContext(ctx contex return o } +func (o TokenRequestArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequest] { + return pulumix.Output[[]TokenRequest]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestArrayOutput) Index(i pulumi.IntInput) TokenRequestOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TokenRequest { return vs[0].([]TokenRequest)[vs[1].(int)] @@ -2741,6 +3078,12 @@ func (i TokenRequestPatchArgs) ToTokenRequestPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TokenRequestPatchOutput) } +func (i TokenRequestPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestPatch] { + return pulumix.Output[TokenRequestPatch]{ + OutputState: i.ToTokenRequestPatchOutputWithContext(ctx).OutputState, + } +} + // TokenRequestPatchArrayInput is an input type that accepts TokenRequestPatchArray and TokenRequestPatchArrayOutput values. // You can construct a concrete instance of `TokenRequestPatchArrayInput` via: // @@ -2766,6 +3109,12 @@ func (i TokenRequestPatchArray) ToTokenRequestPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TokenRequestPatchArrayOutput) } +func (i TokenRequestPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequestPatch] { + return pulumix.Output[[]TokenRequestPatch]{ + OutputState: i.ToTokenRequestPatchArrayOutputWithContext(ctx).OutputState, + } +} + // TokenRequest contains parameters of a service account token. type TokenRequestPatchOutput struct{ *pulumi.OutputState } @@ -2781,6 +3130,12 @@ func (o TokenRequestPatchOutput) ToTokenRequestPatchOutputWithContext(ctx contex return o } +func (o TokenRequestPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestPatch] { + return pulumix.Output[TokenRequestPatch]{ + OutputState: o.OutputState, + } +} + // audience is the intended audience of the token in "TokenRequestSpec". It will default to the audiences of kube apiserver. func (o TokenRequestPatchOutput) Audience() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenRequestPatch) *string { return v.Audience }).(pulumi.StringPtrOutput) @@ -2805,6 +3160,12 @@ func (o TokenRequestPatchArrayOutput) ToTokenRequestPatchArrayOutputWithContext( return o } +func (o TokenRequestPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequestPatch] { + return pulumix.Output[[]TokenRequestPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestPatchArrayOutput) Index(i pulumi.IntInput) TokenRequestPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TokenRequestPatch { return vs[0].([]TokenRequestPatch)[vs[1].(int)] @@ -2866,6 +3227,12 @@ func (i VolumeAttachmentTypeArgs) ToVolumeAttachmentTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentTypeOutput) } +func (i VolumeAttachmentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentType] { + return pulumix.Output[VolumeAttachmentType]{ + OutputState: i.ToVolumeAttachmentTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentTypeArrayInput is an input type that accepts VolumeAttachmentTypeArray and VolumeAttachmentTypeArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentTypeArrayInput` via: // @@ -2891,6 +3258,12 @@ func (i VolumeAttachmentTypeArray) ToVolumeAttachmentTypeArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentTypeArrayOutput) } +func (i VolumeAttachmentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeAttachmentType] { + return pulumix.Output[[]VolumeAttachmentType]{ + OutputState: i.ToVolumeAttachmentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. // // VolumeAttachment objects are non-namespaced. @@ -2908,6 +3281,12 @@ func (o VolumeAttachmentTypeOutput) ToVolumeAttachmentTypeOutputWithContext(ctx return o } +func (o VolumeAttachmentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentType] { + return pulumix.Output[VolumeAttachmentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2947,6 +3326,12 @@ func (o VolumeAttachmentTypeArrayOutput) ToVolumeAttachmentTypeArrayOutputWithCo return o } +func (o VolumeAttachmentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeAttachmentType] { + return pulumix.Output[[]VolumeAttachmentType]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentTypeArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeAttachmentType { return vs[0].([]VolumeAttachmentType)[vs[1].(int)] @@ -3000,6 +3385,12 @@ func (i VolumeAttachmentListTypeArgs) ToVolumeAttachmentListTypeOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListTypeOutput) } +func (i VolumeAttachmentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentListType] { + return pulumix.Output[VolumeAttachmentListType]{ + OutputState: i.ToVolumeAttachmentListTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentList is a collection of VolumeAttachment objects. type VolumeAttachmentListTypeOutput struct{ *pulumi.OutputState } @@ -3015,6 +3406,12 @@ func (o VolumeAttachmentListTypeOutput) ToVolumeAttachmentListTypeOutputWithCont return o } +func (o VolumeAttachmentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentListType] { + return pulumix.Output[VolumeAttachmentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3090,6 +3487,12 @@ func (i VolumeAttachmentPatchTypeArgs) ToVolumeAttachmentPatchTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchTypeOutput) } +func (i VolumeAttachmentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentPatchType] { + return pulumix.Output[VolumeAttachmentPatchType]{ + OutputState: i.ToVolumeAttachmentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. // // VolumeAttachment objects are non-namespaced. @@ -3107,6 +3510,12 @@ func (o VolumeAttachmentPatchTypeOutput) ToVolumeAttachmentPatchTypeOutputWithCo return o } +func (o VolumeAttachmentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentPatchType] { + return pulumix.Output[VolumeAttachmentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3171,6 +3580,12 @@ func (i VolumeAttachmentSourceArgs) ToVolumeAttachmentSourceOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourceOutput) } +func (i VolumeAttachmentSourceArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSource] { + return pulumix.Output[VolumeAttachmentSource]{ + OutputState: i.ToVolumeAttachmentSourceOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. type VolumeAttachmentSourceOutput struct{ *pulumi.OutputState } @@ -3186,6 +3601,12 @@ func (o VolumeAttachmentSourceOutput) ToVolumeAttachmentSourceOutputWithContext( return o } +func (o VolumeAttachmentSourceOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSource] { + return pulumix.Output[VolumeAttachmentSource]{ + OutputState: o.OutputState, + } +} + // inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is beta-level and is only honored by servers that enabled the CSIMigration feature. func (o VolumeAttachmentSourceOutput) InlineVolumeSpec() corev1.PersistentVolumeSpecPtrOutput { return o.ApplyT(func(v VolumeAttachmentSource) *corev1.PersistentVolumeSpec { return v.InlineVolumeSpec }).(corev1.PersistentVolumeSpecPtrOutput) @@ -3235,6 +3656,12 @@ func (i VolumeAttachmentSourcePatchArgs) ToVolumeAttachmentSourcePatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourcePatchOutput) } +func (i VolumeAttachmentSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSourcePatch] { + return pulumix.Output[VolumeAttachmentSourcePatch]{ + OutputState: i.ToVolumeAttachmentSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentSourcePatchArgs) ToVolumeAttachmentSourcePatchPtrOutput() VolumeAttachmentSourcePatchPtrOutput { return i.ToVolumeAttachmentSourcePatchPtrOutputWithContext(context.Background()) } @@ -3276,6 +3703,12 @@ func (i *volumeAttachmentSourcePatchPtrType) ToVolumeAttachmentSourcePatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourcePatchPtrOutput) } +func (i *volumeAttachmentSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSourcePatch] { + return pulumix.Output[*VolumeAttachmentSourcePatch]{ + OutputState: i.ToVolumeAttachmentSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. type VolumeAttachmentSourcePatchOutput struct{ *pulumi.OutputState } @@ -3301,6 +3734,12 @@ func (o VolumeAttachmentSourcePatchOutput) ToVolumeAttachmentSourcePatchPtrOutpu }).(VolumeAttachmentSourcePatchPtrOutput) } +func (o VolumeAttachmentSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSourcePatch] { + return pulumix.Output[VolumeAttachmentSourcePatch]{ + OutputState: o.OutputState, + } +} + // inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is beta-level and is only honored by servers that enabled the CSIMigration feature. func (o VolumeAttachmentSourcePatchOutput) InlineVolumeSpec() corev1.PersistentVolumeSpecPatchPtrOutput { return o.ApplyT(func(v VolumeAttachmentSourcePatch) *corev1.PersistentVolumeSpecPatch { return v.InlineVolumeSpec }).(corev1.PersistentVolumeSpecPatchPtrOutput) @@ -3325,6 +3764,12 @@ func (o VolumeAttachmentSourcePatchPtrOutput) ToVolumeAttachmentSourcePatchPtrOu return o } +func (o VolumeAttachmentSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSourcePatch] { + return pulumix.Output[*VolumeAttachmentSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentSourcePatchPtrOutput) Elem() VolumeAttachmentSourcePatchOutput { return o.ApplyT(func(v *VolumeAttachmentSourcePatch) VolumeAttachmentSourcePatch { if v != nil { @@ -3398,6 +3843,12 @@ func (i VolumeAttachmentSpecArgs) ToVolumeAttachmentSpecOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecOutput) } +func (i VolumeAttachmentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpec] { + return pulumix.Output[VolumeAttachmentSpec]{ + OutputState: i.ToVolumeAttachmentSpecOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSpec is the specification of a VolumeAttachment request. type VolumeAttachmentSpecOutput struct{ *pulumi.OutputState } @@ -3413,6 +3864,12 @@ func (o VolumeAttachmentSpecOutput) ToVolumeAttachmentSpecOutputWithContext(ctx return o } +func (o VolumeAttachmentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpec] { + return pulumix.Output[VolumeAttachmentSpec]{ + OutputState: o.OutputState, + } +} + // attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). func (o VolumeAttachmentSpecOutput) Attacher() pulumi.StringOutput { return o.ApplyT(func(v VolumeAttachmentSpec) string { return v.Attacher }).(pulumi.StringOutput) @@ -3471,6 +3928,12 @@ func (i VolumeAttachmentSpecPatchArgs) ToVolumeAttachmentSpecPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecPatchOutput) } +func (i VolumeAttachmentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpecPatch] { + return pulumix.Output[VolumeAttachmentSpecPatch]{ + OutputState: i.ToVolumeAttachmentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentSpecPatchArgs) ToVolumeAttachmentSpecPatchPtrOutput() VolumeAttachmentSpecPatchPtrOutput { return i.ToVolumeAttachmentSpecPatchPtrOutputWithContext(context.Background()) } @@ -3512,6 +3975,12 @@ func (i *volumeAttachmentSpecPatchPtrType) ToVolumeAttachmentSpecPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecPatchPtrOutput) } +func (i *volumeAttachmentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSpecPatch] { + return pulumix.Output[*VolumeAttachmentSpecPatch]{ + OutputState: i.ToVolumeAttachmentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSpec is the specification of a VolumeAttachment request. type VolumeAttachmentSpecPatchOutput struct{ *pulumi.OutputState } @@ -3537,6 +4006,12 @@ func (o VolumeAttachmentSpecPatchOutput) ToVolumeAttachmentSpecPatchPtrOutputWit }).(VolumeAttachmentSpecPatchPtrOutput) } +func (o VolumeAttachmentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpecPatch] { + return pulumix.Output[VolumeAttachmentSpecPatch]{ + OutputState: o.OutputState, + } +} + // attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). func (o VolumeAttachmentSpecPatchOutput) Attacher() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentSpecPatch) *string { return v.Attacher }).(pulumi.StringPtrOutput) @@ -3566,6 +4041,12 @@ func (o VolumeAttachmentSpecPatchPtrOutput) ToVolumeAttachmentSpecPatchPtrOutput return o } +func (o VolumeAttachmentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSpecPatch] { + return pulumix.Output[*VolumeAttachmentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentSpecPatchPtrOutput) Elem() VolumeAttachmentSpecPatchOutput { return o.ApplyT(func(v *VolumeAttachmentSpecPatch) VolumeAttachmentSpecPatch { if v != nil { @@ -3653,6 +4134,12 @@ func (i VolumeAttachmentStatusArgs) ToVolumeAttachmentStatusOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusOutput) } +func (i VolumeAttachmentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatus] { + return pulumix.Output[VolumeAttachmentStatus]{ + OutputState: i.ToVolumeAttachmentStatusOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentStatusArgs) ToVolumeAttachmentStatusPtrOutput() VolumeAttachmentStatusPtrOutput { return i.ToVolumeAttachmentStatusPtrOutputWithContext(context.Background()) } @@ -3694,6 +4181,12 @@ func (i *volumeAttachmentStatusPtrType) ToVolumeAttachmentStatusPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPtrOutput) } +func (i *volumeAttachmentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatus] { + return pulumix.Output[*VolumeAttachmentStatus]{ + OutputState: i.ToVolumeAttachmentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentStatus is the status of a VolumeAttachment request. type VolumeAttachmentStatusOutput struct{ *pulumi.OutputState } @@ -3719,6 +4212,12 @@ func (o VolumeAttachmentStatusOutput) ToVolumeAttachmentStatusPtrOutputWithConte }).(VolumeAttachmentStatusPtrOutput) } +func (o VolumeAttachmentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatus] { + return pulumix.Output[VolumeAttachmentStatus]{ + OutputState: o.OutputState, + } +} + // attachError represents the last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. func (o VolumeAttachmentStatusOutput) AttachError() VolumeErrorPtrOutput { return o.ApplyT(func(v VolumeAttachmentStatus) *VolumeError { return v.AttachError }).(VolumeErrorPtrOutput) @@ -3753,6 +4252,12 @@ func (o VolumeAttachmentStatusPtrOutput) ToVolumeAttachmentStatusPtrOutputWithCo return o } +func (o VolumeAttachmentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatus] { + return pulumix.Output[*VolumeAttachmentStatus]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentStatusPtrOutput) Elem() VolumeAttachmentStatusOutput { return o.ApplyT(func(v *VolumeAttachmentStatus) VolumeAttachmentStatus { if v != nil { @@ -3850,6 +4355,12 @@ func (i VolumeAttachmentStatusPatchArgs) ToVolumeAttachmentStatusPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPatchOutput) } +func (i VolumeAttachmentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatusPatch] { + return pulumix.Output[VolumeAttachmentStatusPatch]{ + OutputState: i.ToVolumeAttachmentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentStatusPatchArgs) ToVolumeAttachmentStatusPatchPtrOutput() VolumeAttachmentStatusPatchPtrOutput { return i.ToVolumeAttachmentStatusPatchPtrOutputWithContext(context.Background()) } @@ -3891,6 +4402,12 @@ func (i *volumeAttachmentStatusPatchPtrType) ToVolumeAttachmentStatusPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPatchPtrOutput) } +func (i *volumeAttachmentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatusPatch] { + return pulumix.Output[*VolumeAttachmentStatusPatch]{ + OutputState: i.ToVolumeAttachmentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentStatus is the status of a VolumeAttachment request. type VolumeAttachmentStatusPatchOutput struct{ *pulumi.OutputState } @@ -3916,6 +4433,12 @@ func (o VolumeAttachmentStatusPatchOutput) ToVolumeAttachmentStatusPatchPtrOutpu }).(VolumeAttachmentStatusPatchPtrOutput) } +func (o VolumeAttachmentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatusPatch] { + return pulumix.Output[VolumeAttachmentStatusPatch]{ + OutputState: o.OutputState, + } +} + // attachError represents the last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. func (o VolumeAttachmentStatusPatchOutput) AttachError() VolumeErrorPatchPtrOutput { return o.ApplyT(func(v VolumeAttachmentStatusPatch) *VolumeErrorPatch { return v.AttachError }).(VolumeErrorPatchPtrOutput) @@ -3950,6 +4473,12 @@ func (o VolumeAttachmentStatusPatchPtrOutput) ToVolumeAttachmentStatusPatchPtrOu return o } +func (o VolumeAttachmentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatusPatch] { + return pulumix.Output[*VolumeAttachmentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentStatusPatchPtrOutput) Elem() VolumeAttachmentStatusPatchOutput { return o.ApplyT(func(v *VolumeAttachmentStatusPatch) VolumeAttachmentStatusPatch { if v != nil { @@ -4039,6 +4568,12 @@ func (i VolumeErrorArgs) ToVolumeErrorOutputWithContext(ctx context.Context) Vol return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorOutput) } +func (i VolumeErrorArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeError] { + return pulumix.Output[VolumeError]{ + OutputState: i.ToVolumeErrorOutputWithContext(ctx).OutputState, + } +} + func (i VolumeErrorArgs) ToVolumeErrorPtrOutput() VolumeErrorPtrOutput { return i.ToVolumeErrorPtrOutputWithContext(context.Background()) } @@ -4080,6 +4615,12 @@ func (i *volumeErrorPtrType) ToVolumeErrorPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPtrOutput) } +func (i *volumeErrorPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeError] { + return pulumix.Output[*VolumeError]{ + OutputState: i.ToVolumeErrorPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeError captures an error encountered during a volume operation. type VolumeErrorOutput struct{ *pulumi.OutputState } @@ -4105,6 +4646,12 @@ func (o VolumeErrorOutput) ToVolumeErrorPtrOutputWithContext(ctx context.Context }).(VolumeErrorPtrOutput) } +func (o VolumeErrorOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeError] { + return pulumix.Output[VolumeError]{ + OutputState: o.OutputState, + } +} + // message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. func (o VolumeErrorOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeError) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -4129,6 +4676,12 @@ func (o VolumeErrorPtrOutput) ToVolumeErrorPtrOutputWithContext(ctx context.Cont return o } +func (o VolumeErrorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeError] { + return pulumix.Output[*VolumeError]{ + OutputState: o.OutputState, + } +} + func (o VolumeErrorPtrOutput) Elem() VolumeErrorOutput { return o.ApplyT(func(v *VolumeError) VolumeError { if v != nil { @@ -4198,6 +4751,12 @@ func (i VolumeErrorPatchArgs) ToVolumeErrorPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPatchOutput) } +func (i VolumeErrorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeErrorPatch] { + return pulumix.Output[VolumeErrorPatch]{ + OutputState: i.ToVolumeErrorPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeErrorPatchArgs) ToVolumeErrorPatchPtrOutput() VolumeErrorPatchPtrOutput { return i.ToVolumeErrorPatchPtrOutputWithContext(context.Background()) } @@ -4239,6 +4798,12 @@ func (i *volumeErrorPatchPtrType) ToVolumeErrorPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPatchPtrOutput) } +func (i *volumeErrorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeErrorPatch] { + return pulumix.Output[*VolumeErrorPatch]{ + OutputState: i.ToVolumeErrorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeError captures an error encountered during a volume operation. type VolumeErrorPatchOutput struct{ *pulumi.OutputState } @@ -4264,6 +4829,12 @@ func (o VolumeErrorPatchOutput) ToVolumeErrorPatchPtrOutputWithContext(ctx conte }).(VolumeErrorPatchPtrOutput) } +func (o VolumeErrorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeErrorPatch] { + return pulumix.Output[VolumeErrorPatch]{ + OutputState: o.OutputState, + } +} + // message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. func (o VolumeErrorPatchOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeErrorPatch) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -4288,6 +4859,12 @@ func (o VolumeErrorPatchPtrOutput) ToVolumeErrorPatchPtrOutputWithContext(ctx co return o } +func (o VolumeErrorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeErrorPatch] { + return pulumix.Output[*VolumeErrorPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeErrorPatchPtrOutput) Elem() VolumeErrorPatchOutput { return o.ApplyT(func(v *VolumeErrorPatch) VolumeErrorPatch { if v != nil { @@ -4353,6 +4930,12 @@ func (i VolumeNodeResourcesArgs) ToVolumeNodeResourcesOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesOutput) } +func (i VolumeNodeResourcesArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResources] { + return pulumix.Output[VolumeNodeResources]{ + OutputState: i.ToVolumeNodeResourcesOutputWithContext(ctx).OutputState, + } +} + func (i VolumeNodeResourcesArgs) ToVolumeNodeResourcesPtrOutput() VolumeNodeResourcesPtrOutput { return i.ToVolumeNodeResourcesPtrOutputWithContext(context.Background()) } @@ -4394,6 +4977,12 @@ func (i *volumeNodeResourcesPtrType) ToVolumeNodeResourcesPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesPtrOutput) } +func (i *volumeNodeResourcesPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResources] { + return pulumix.Output[*VolumeNodeResources]{ + OutputState: i.ToVolumeNodeResourcesPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeNodeResources is a set of resource limits for scheduling of volumes. type VolumeNodeResourcesOutput struct{ *pulumi.OutputState } @@ -4419,6 +5008,12 @@ func (o VolumeNodeResourcesOutput) ToVolumeNodeResourcesPtrOutputWithContext(ctx }).(VolumeNodeResourcesPtrOutput) } +func (o VolumeNodeResourcesOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResources] { + return pulumix.Output[VolumeNodeResources]{ + OutputState: o.OutputState, + } +} + // count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded. func (o VolumeNodeResourcesOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v VolumeNodeResources) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -4438,6 +5033,12 @@ func (o VolumeNodeResourcesPtrOutput) ToVolumeNodeResourcesPtrOutputWithContext( return o } +func (o VolumeNodeResourcesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResources] { + return pulumix.Output[*VolumeNodeResources]{ + OutputState: o.OutputState, + } +} + func (o VolumeNodeResourcesPtrOutput) Elem() VolumeNodeResourcesOutput { return o.ApplyT(func(v *VolumeNodeResources) VolumeNodeResources { if v != nil { @@ -4493,6 +5094,12 @@ func (i VolumeNodeResourcesPatchArgs) ToVolumeNodeResourcesPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesPatchOutput) } +func (i VolumeNodeResourcesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResourcesPatch] { + return pulumix.Output[VolumeNodeResourcesPatch]{ + OutputState: i.ToVolumeNodeResourcesPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeNodeResourcesPatchArgs) ToVolumeNodeResourcesPatchPtrOutput() VolumeNodeResourcesPatchPtrOutput { return i.ToVolumeNodeResourcesPatchPtrOutputWithContext(context.Background()) } @@ -4534,6 +5141,12 @@ func (i *volumeNodeResourcesPatchPtrType) ToVolumeNodeResourcesPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesPatchPtrOutput) } +func (i *volumeNodeResourcesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResourcesPatch] { + return pulumix.Output[*VolumeNodeResourcesPatch]{ + OutputState: i.ToVolumeNodeResourcesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeNodeResources is a set of resource limits for scheduling of volumes. type VolumeNodeResourcesPatchOutput struct{ *pulumi.OutputState } @@ -4559,6 +5172,12 @@ func (o VolumeNodeResourcesPatchOutput) ToVolumeNodeResourcesPatchPtrOutputWithC }).(VolumeNodeResourcesPatchPtrOutput) } +func (o VolumeNodeResourcesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResourcesPatch] { + return pulumix.Output[VolumeNodeResourcesPatch]{ + OutputState: o.OutputState, + } +} + // count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded. func (o VolumeNodeResourcesPatchOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v VolumeNodeResourcesPatch) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -4578,6 +5197,12 @@ func (o VolumeNodeResourcesPatchPtrOutput) ToVolumeNodeResourcesPatchPtrOutputWi return o } +func (o VolumeNodeResourcesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResourcesPatch] { + return pulumix.Output[*VolumeNodeResourcesPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeNodeResourcesPatchPtrOutput) Elem() VolumeNodeResourcesPatchOutput { return o.ApplyT(func(v *VolumeNodeResourcesPatch) VolumeNodeResourcesPatch { if v != nil { diff --git a/sdk/go/kubernetes/storage/v1/storageClass.go b/sdk/go/kubernetes/storage/v1/storageClass.go index 3d4bed07af..2eb1736338 100644 --- a/sdk/go/kubernetes/storage/v1/storageClass.go +++ b/sdk/go/kubernetes/storage/v1/storageClass.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. @@ -162,6 +163,12 @@ func (i *StorageClass) ToStorageClassOutputWithContext(ctx context.Context) Stor return pulumi.ToOutputWithContext(ctx, i).(StorageClassOutput) } +func (i *StorageClass) ToOutput(ctx context.Context) pulumix.Output[*StorageClass] { + return pulumix.Output[*StorageClass]{ + OutputState: i.ToStorageClassOutputWithContext(ctx).OutputState, + } +} + // StorageClassArrayInput is an input type that accepts StorageClassArray and StorageClassArrayOutput values. // You can construct a concrete instance of `StorageClassArrayInput` via: // @@ -187,6 +194,12 @@ func (i StorageClassArray) ToStorageClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StorageClassArrayOutput) } +func (i StorageClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClass] { + return pulumix.Output[[]*StorageClass]{ + OutputState: i.ToStorageClassArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClassMapInput is an input type that accepts StorageClassMap and StorageClassMapOutput values. // You can construct a concrete instance of `StorageClassMapInput` via: // @@ -212,6 +225,12 @@ func (i StorageClassMap) ToStorageClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(StorageClassMapOutput) } +func (i StorageClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClass] { + return pulumix.Output[map[string]*StorageClass]{ + OutputState: i.ToStorageClassMapOutputWithContext(ctx).OutputState, + } +} + type StorageClassOutput struct{ *pulumi.OutputState } func (StorageClassOutput) ElementType() reflect.Type { @@ -226,6 +245,12 @@ func (o StorageClassOutput) ToStorageClassOutputWithContext(ctx context.Context) return o } +func (o StorageClassOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageClass] { + return pulumix.Output[*StorageClass]{ + OutputState: o.OutputState, + } +} + // allowVolumeExpansion shows whether the storage class allow volume expand. func (o StorageClassOutput) AllowVolumeExpansion() pulumi.BoolOutput { return o.ApplyT(func(v *StorageClass) pulumi.BoolOutput { return v.AllowVolumeExpansion }).(pulumi.BoolOutput) @@ -290,6 +315,12 @@ func (o StorageClassArrayOutput) ToStorageClassArrayOutputWithContext(ctx contex return o } +func (o StorageClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClass] { + return pulumix.Output[[]*StorageClass]{ + OutputState: o.OutputState, + } +} + func (o StorageClassArrayOutput) Index(i pulumi.IntInput) StorageClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StorageClass { return vs[0].([]*StorageClass)[vs[1].(int)] @@ -310,6 +341,12 @@ func (o StorageClassMapOutput) ToStorageClassMapOutputWithContext(ctx context.Co return o } +func (o StorageClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClass] { + return pulumix.Output[map[string]*StorageClass]{ + OutputState: o.OutputState, + } +} + func (o StorageClassMapOutput) MapIndex(k pulumi.StringInput) StorageClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StorageClass { return vs[0].(map[string]*StorageClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/storageClassList.go b/sdk/go/kubernetes/storage/v1/storageClassList.go index 3d1dc0f79d..6c67e0c09a 100644 --- a/sdk/go/kubernetes/storage/v1/storageClassList.go +++ b/sdk/go/kubernetes/storage/v1/storageClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StorageClassList is a collection of storage classes. @@ -117,6 +118,12 @@ func (i *StorageClassList) ToStorageClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StorageClassListOutput) } +func (i *StorageClassList) ToOutput(ctx context.Context) pulumix.Output[*StorageClassList] { + return pulumix.Output[*StorageClassList]{ + OutputState: i.ToStorageClassListOutputWithContext(ctx).OutputState, + } +} + // StorageClassListArrayInput is an input type that accepts StorageClassListArray and StorageClassListArrayOutput values. // You can construct a concrete instance of `StorageClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i StorageClassListArray) ToStorageClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StorageClassListArrayOutput) } +func (i StorageClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassList] { + return pulumix.Output[[]*StorageClassList]{ + OutputState: i.ToStorageClassListArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClassListMapInput is an input type that accepts StorageClassListMap and StorageClassListMapOutput values. // You can construct a concrete instance of `StorageClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i StorageClassListMap) ToStorageClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StorageClassListMapOutput) } +func (i StorageClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassList] { + return pulumix.Output[map[string]*StorageClassList]{ + OutputState: i.ToStorageClassListMapOutputWithContext(ctx).OutputState, + } +} + type StorageClassListOutput struct{ *pulumi.OutputState } func (StorageClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o StorageClassListOutput) ToStorageClassListOutputWithContext(ctx context. return o } +func (o StorageClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageClassList] { + return pulumix.Output[*StorageClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StorageClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StorageClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o StorageClassListArrayOutput) ToStorageClassListArrayOutputWithContext(ct return o } +func (o StorageClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassList] { + return pulumix.Output[[]*StorageClassList]{ + OutputState: o.OutputState, + } +} + func (o StorageClassListArrayOutput) Index(i pulumi.IntInput) StorageClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StorageClassList { return vs[0].([]*StorageClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o StorageClassListMapOutput) ToStorageClassListMapOutputWithContext(ctx co return o } +func (o StorageClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassList] { + return pulumix.Output[map[string]*StorageClassList]{ + OutputState: o.OutputState, + } +} + func (o StorageClassListMapOutput) MapIndex(k pulumi.StringInput) StorageClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StorageClassList { return vs[0].(map[string]*StorageClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/storageClassPatch.go b/sdk/go/kubernetes/storage/v1/storageClassPatch.go index f1552ebc35..03e40aa498 100644 --- a/sdk/go/kubernetes/storage/v1/storageClassPatch.go +++ b/sdk/go/kubernetes/storage/v1/storageClassPatch.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -164,6 +165,12 @@ func (i *StorageClassPatch) ToStorageClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchOutput) } +func (i *StorageClassPatch) ToOutput(ctx context.Context) pulumix.Output[*StorageClassPatch] { + return pulumix.Output[*StorageClassPatch]{ + OutputState: i.ToStorageClassPatchOutputWithContext(ctx).OutputState, + } +} + // StorageClassPatchArrayInput is an input type that accepts StorageClassPatchArray and StorageClassPatchArrayOutput values. // You can construct a concrete instance of `StorageClassPatchArrayInput` via: // @@ -189,6 +196,12 @@ func (i StorageClassPatchArray) ToStorageClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchArrayOutput) } +func (i StorageClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassPatch] { + return pulumix.Output[[]*StorageClassPatch]{ + OutputState: i.ToStorageClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClassPatchMapInput is an input type that accepts StorageClassPatchMap and StorageClassPatchMapOutput values. // You can construct a concrete instance of `StorageClassPatchMapInput` via: // @@ -214,6 +227,12 @@ func (i StorageClassPatchMap) ToStorageClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchMapOutput) } +func (i StorageClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassPatch] { + return pulumix.Output[map[string]*StorageClassPatch]{ + OutputState: i.ToStorageClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type StorageClassPatchOutput struct{ *pulumi.OutputState } func (StorageClassPatchOutput) ElementType() reflect.Type { @@ -228,6 +247,12 @@ func (o StorageClassPatchOutput) ToStorageClassPatchOutputWithContext(ctx contex return o } +func (o StorageClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageClassPatch] { + return pulumix.Output[*StorageClassPatch]{ + OutputState: o.OutputState, + } +} + // allowVolumeExpansion shows whether the storage class allow volume expand. func (o StorageClassPatchOutput) AllowVolumeExpansion() pulumi.BoolPtrOutput { return o.ApplyT(func(v *StorageClassPatch) pulumi.BoolPtrOutput { return v.AllowVolumeExpansion }).(pulumi.BoolPtrOutput) @@ -292,6 +317,12 @@ func (o StorageClassPatchArrayOutput) ToStorageClassPatchArrayOutputWithContext( return o } +func (o StorageClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassPatch] { + return pulumix.Output[[]*StorageClassPatch]{ + OutputState: o.OutputState, + } +} + func (o StorageClassPatchArrayOutput) Index(i pulumi.IntInput) StorageClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StorageClassPatch { return vs[0].([]*StorageClassPatch)[vs[1].(int)] @@ -312,6 +343,12 @@ func (o StorageClassPatchMapOutput) ToStorageClassPatchMapOutputWithContext(ctx return o } +func (o StorageClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassPatch] { + return pulumix.Output[map[string]*StorageClassPatch]{ + OutputState: o.OutputState, + } +} + func (o StorageClassPatchMapOutput) MapIndex(k pulumi.StringInput) StorageClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StorageClassPatch { return vs[0].(map[string]*StorageClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/volumeAttachment.go b/sdk/go/kubernetes/storage/v1/volumeAttachment.go index 7a06c8b0dc..f2804bd2dd 100644 --- a/sdk/go/kubernetes/storage/v1/volumeAttachment.go +++ b/sdk/go/kubernetes/storage/v1/volumeAttachment.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. @@ -130,6 +131,12 @@ func (i *VolumeAttachment) ToVolumeAttachmentOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentOutput) } +func (i *VolumeAttachment) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachment] { + return pulumix.Output[*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentArrayInput is an input type that accepts VolumeAttachmentArray and VolumeAttachmentArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentArrayInput` via: // @@ -155,6 +162,12 @@ func (i VolumeAttachmentArray) ToVolumeAttachmentArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentArrayOutput) } +func (i VolumeAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachment] { + return pulumix.Output[[]*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentMapInput is an input type that accepts VolumeAttachmentMap and VolumeAttachmentMapOutput values. // You can construct a concrete instance of `VolumeAttachmentMapInput` via: // @@ -180,6 +193,12 @@ func (i VolumeAttachmentMap) ToVolumeAttachmentMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentMapOutput) } +func (i VolumeAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachment] { + return pulumix.Output[map[string]*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentOutput struct{ *pulumi.OutputState } func (VolumeAttachmentOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o VolumeAttachmentOutput) ToVolumeAttachmentOutputWithContext(ctx context. return o } +func (o VolumeAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachment] { + return pulumix.Output[*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *VolumeAttachment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -233,6 +258,12 @@ func (o VolumeAttachmentArrayOutput) ToVolumeAttachmentArrayOutputWithContext(ct return o } +func (o VolumeAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachment] { + return pulumix.Output[[]*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachment { return vs[0].([]*VolumeAttachment)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o VolumeAttachmentMapOutput) ToVolumeAttachmentMapOutputWithContext(ctx co return o } +func (o VolumeAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachment] { + return pulumix.Output[map[string]*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachment { return vs[0].(map[string]*VolumeAttachment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/volumeAttachmentList.go b/sdk/go/kubernetes/storage/v1/volumeAttachmentList.go index d25ce60b70..4572ce0746 100644 --- a/sdk/go/kubernetes/storage/v1/volumeAttachmentList.go +++ b/sdk/go/kubernetes/storage/v1/volumeAttachmentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // VolumeAttachmentList is a collection of VolumeAttachment objects. @@ -117,6 +118,12 @@ func (i *VolumeAttachmentList) ToVolumeAttachmentListOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListOutput) } +func (i *VolumeAttachmentList) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentList] { + return pulumix.Output[*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentListArrayInput is an input type that accepts VolumeAttachmentListArray and VolumeAttachmentListArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i VolumeAttachmentListArray) ToVolumeAttachmentListArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListArrayOutput) } +func (i VolumeAttachmentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentList] { + return pulumix.Output[[]*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentListMapInput is an input type that accepts VolumeAttachmentListMap and VolumeAttachmentListMapOutput values. // You can construct a concrete instance of `VolumeAttachmentListMapInput` via: // @@ -167,6 +180,12 @@ func (i VolumeAttachmentListMap) ToVolumeAttachmentListMapOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListMapOutput) } +func (i VolumeAttachmentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentList] { + return pulumix.Output[map[string]*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentListOutput struct{ *pulumi.OutputState } func (VolumeAttachmentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o VolumeAttachmentListOutput) ToVolumeAttachmentListOutputWithContext(ctx return o } +func (o VolumeAttachmentListOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentList] { + return pulumix.Output[*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *VolumeAttachmentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o VolumeAttachmentListArrayOutput) ToVolumeAttachmentListArrayOutputWithCo return o } +func (o VolumeAttachmentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentList] { + return pulumix.Output[[]*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentListArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachmentList { return vs[0].([]*VolumeAttachmentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o VolumeAttachmentListMapOutput) ToVolumeAttachmentListMapOutputWithContex return o } +func (o VolumeAttachmentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentList] { + return pulumix.Output[map[string]*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentListMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachmentList { return vs[0].(map[string]*VolumeAttachmentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1/volumeAttachmentPatch.go b/sdk/go/kubernetes/storage/v1/volumeAttachmentPatch.go index c2d2d28ce7..5798bba171 100644 --- a/sdk/go/kubernetes/storage/v1/volumeAttachmentPatch.go +++ b/sdk/go/kubernetes/storage/v1/volumeAttachmentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *VolumeAttachmentPatch) ToVolumeAttachmentPatchOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchOutput) } +func (i *VolumeAttachmentPatch) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentPatch] { + return pulumix.Output[*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentPatchArrayInput is an input type that accepts VolumeAttachmentPatchArray and VolumeAttachmentPatchArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i VolumeAttachmentPatchArray) ToVolumeAttachmentPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchArrayOutput) } +func (i VolumeAttachmentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentPatch] { + return pulumix.Output[[]*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentPatchMapInput is an input type that accepts VolumeAttachmentPatchMap and VolumeAttachmentPatchMapOutput values. // You can construct a concrete instance of `VolumeAttachmentPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i VolumeAttachmentPatchMap) ToVolumeAttachmentPatchMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchMapOutput) } +func (i VolumeAttachmentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentPatch] { + return pulumix.Output[map[string]*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentPatchOutput struct{ *pulumi.OutputState } func (VolumeAttachmentPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o VolumeAttachmentPatchOutput) ToVolumeAttachmentPatchOutputWithContext(ct return o } +func (o VolumeAttachmentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentPatch] { + return pulumix.Output[*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *VolumeAttachmentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o VolumeAttachmentPatchArrayOutput) ToVolumeAttachmentPatchArrayOutputWith return o } +func (o VolumeAttachmentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentPatch] { + return pulumix.Output[[]*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentPatchArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachmentPatch { return vs[0].([]*VolumeAttachmentPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o VolumeAttachmentPatchMapOutput) ToVolumeAttachmentPatchMapOutputWithCont return o } +func (o VolumeAttachmentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentPatch] { + return pulumix.Output[map[string]*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentPatchMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachmentPatch { return vs[0].(map[string]*VolumeAttachmentPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1alpha1/pulumiTypes.go b/sdk/go/kubernetes/storage/v1alpha1/pulumiTypes.go index f8384fde33..125b727ca5 100644 --- a/sdk/go/kubernetes/storage/v1alpha1/pulumiTypes.go +++ b/sdk/go/kubernetes/storage/v1alpha1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -70,6 +71,12 @@ func (i VolumeAttachmentTypeArgs) ToVolumeAttachmentTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentTypeOutput) } +func (i VolumeAttachmentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentType] { + return pulumix.Output[VolumeAttachmentType]{ + OutputState: i.ToVolumeAttachmentTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentTypeArrayInput is an input type that accepts VolumeAttachmentTypeArray and VolumeAttachmentTypeArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentTypeArrayInput` via: // @@ -95,6 +102,12 @@ func (i VolumeAttachmentTypeArray) ToVolumeAttachmentTypeArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentTypeArrayOutput) } +func (i VolumeAttachmentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeAttachmentType] { + return pulumix.Output[[]VolumeAttachmentType]{ + OutputState: i.ToVolumeAttachmentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. // // VolumeAttachment objects are non-namespaced. @@ -112,6 +125,12 @@ func (o VolumeAttachmentTypeOutput) ToVolumeAttachmentTypeOutputWithContext(ctx return o } +func (o VolumeAttachmentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentType] { + return pulumix.Output[VolumeAttachmentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -151,6 +170,12 @@ func (o VolumeAttachmentTypeArrayOutput) ToVolumeAttachmentTypeArrayOutputWithCo return o } +func (o VolumeAttachmentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeAttachmentType] { + return pulumix.Output[[]VolumeAttachmentType]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentTypeArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeAttachmentType { return vs[0].([]VolumeAttachmentType)[vs[1].(int)] @@ -204,6 +229,12 @@ func (i VolumeAttachmentListTypeArgs) ToVolumeAttachmentListTypeOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListTypeOutput) } +func (i VolumeAttachmentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentListType] { + return pulumix.Output[VolumeAttachmentListType]{ + OutputState: i.ToVolumeAttachmentListTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentList is a collection of VolumeAttachment objects. type VolumeAttachmentListTypeOutput struct{ *pulumi.OutputState } @@ -219,6 +250,12 @@ func (o VolumeAttachmentListTypeOutput) ToVolumeAttachmentListTypeOutputWithCont return o } +func (o VolumeAttachmentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentListType] { + return pulumix.Output[VolumeAttachmentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -294,6 +331,12 @@ func (i VolumeAttachmentPatchTypeArgs) ToVolumeAttachmentPatchTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchTypeOutput) } +func (i VolumeAttachmentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentPatchType] { + return pulumix.Output[VolumeAttachmentPatchType]{ + OutputState: i.ToVolumeAttachmentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. // // VolumeAttachment objects are non-namespaced. @@ -311,6 +354,12 @@ func (o VolumeAttachmentPatchTypeOutput) ToVolumeAttachmentPatchTypeOutputWithCo return o } +func (o VolumeAttachmentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentPatchType] { + return pulumix.Output[VolumeAttachmentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -375,6 +424,12 @@ func (i VolumeAttachmentSourceArgs) ToVolumeAttachmentSourceOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourceOutput) } +func (i VolumeAttachmentSourceArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSource] { + return pulumix.Output[VolumeAttachmentSource]{ + OutputState: i.ToVolumeAttachmentSourceOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. type VolumeAttachmentSourceOutput struct{ *pulumi.OutputState } @@ -390,6 +445,12 @@ func (o VolumeAttachmentSourceOutput) ToVolumeAttachmentSourceOutputWithContext( return o } +func (o VolumeAttachmentSourceOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSource] { + return pulumix.Output[VolumeAttachmentSource]{ + OutputState: o.OutputState, + } +} + // inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is alpha-level and is only honored by servers that enabled the CSIMigration feature. func (o VolumeAttachmentSourceOutput) InlineVolumeSpec() corev1.PersistentVolumeSpecPtrOutput { return o.ApplyT(func(v VolumeAttachmentSource) *corev1.PersistentVolumeSpec { return v.InlineVolumeSpec }).(corev1.PersistentVolumeSpecPtrOutput) @@ -439,6 +500,12 @@ func (i VolumeAttachmentSourcePatchArgs) ToVolumeAttachmentSourcePatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourcePatchOutput) } +func (i VolumeAttachmentSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSourcePatch] { + return pulumix.Output[VolumeAttachmentSourcePatch]{ + OutputState: i.ToVolumeAttachmentSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentSourcePatchArgs) ToVolumeAttachmentSourcePatchPtrOutput() VolumeAttachmentSourcePatchPtrOutput { return i.ToVolumeAttachmentSourcePatchPtrOutputWithContext(context.Background()) } @@ -480,6 +547,12 @@ func (i *volumeAttachmentSourcePatchPtrType) ToVolumeAttachmentSourcePatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourcePatchPtrOutput) } +func (i *volumeAttachmentSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSourcePatch] { + return pulumix.Output[*VolumeAttachmentSourcePatch]{ + OutputState: i.ToVolumeAttachmentSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. type VolumeAttachmentSourcePatchOutput struct{ *pulumi.OutputState } @@ -505,6 +578,12 @@ func (o VolumeAttachmentSourcePatchOutput) ToVolumeAttachmentSourcePatchPtrOutpu }).(VolumeAttachmentSourcePatchPtrOutput) } +func (o VolumeAttachmentSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSourcePatch] { + return pulumix.Output[VolumeAttachmentSourcePatch]{ + OutputState: o.OutputState, + } +} + // inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is alpha-level and is only honored by servers that enabled the CSIMigration feature. func (o VolumeAttachmentSourcePatchOutput) InlineVolumeSpec() corev1.PersistentVolumeSpecPatchPtrOutput { return o.ApplyT(func(v VolumeAttachmentSourcePatch) *corev1.PersistentVolumeSpecPatch { return v.InlineVolumeSpec }).(corev1.PersistentVolumeSpecPatchPtrOutput) @@ -529,6 +608,12 @@ func (o VolumeAttachmentSourcePatchPtrOutput) ToVolumeAttachmentSourcePatchPtrOu return o } +func (o VolumeAttachmentSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSourcePatch] { + return pulumix.Output[*VolumeAttachmentSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentSourcePatchPtrOutput) Elem() VolumeAttachmentSourcePatchOutput { return o.ApplyT(func(v *VolumeAttachmentSourcePatch) VolumeAttachmentSourcePatch { if v != nil { @@ -602,6 +687,12 @@ func (i VolumeAttachmentSpecArgs) ToVolumeAttachmentSpecOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecOutput) } +func (i VolumeAttachmentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpec] { + return pulumix.Output[VolumeAttachmentSpec]{ + OutputState: i.ToVolumeAttachmentSpecOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSpec is the specification of a VolumeAttachment request. type VolumeAttachmentSpecOutput struct{ *pulumi.OutputState } @@ -617,6 +708,12 @@ func (o VolumeAttachmentSpecOutput) ToVolumeAttachmentSpecOutputWithContext(ctx return o } +func (o VolumeAttachmentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpec] { + return pulumix.Output[VolumeAttachmentSpec]{ + OutputState: o.OutputState, + } +} + // Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). func (o VolumeAttachmentSpecOutput) Attacher() pulumi.StringOutput { return o.ApplyT(func(v VolumeAttachmentSpec) string { return v.Attacher }).(pulumi.StringOutput) @@ -675,6 +772,12 @@ func (i VolumeAttachmentSpecPatchArgs) ToVolumeAttachmentSpecPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecPatchOutput) } +func (i VolumeAttachmentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpecPatch] { + return pulumix.Output[VolumeAttachmentSpecPatch]{ + OutputState: i.ToVolumeAttachmentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentSpecPatchArgs) ToVolumeAttachmentSpecPatchPtrOutput() VolumeAttachmentSpecPatchPtrOutput { return i.ToVolumeAttachmentSpecPatchPtrOutputWithContext(context.Background()) } @@ -716,6 +819,12 @@ func (i *volumeAttachmentSpecPatchPtrType) ToVolumeAttachmentSpecPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecPatchPtrOutput) } +func (i *volumeAttachmentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSpecPatch] { + return pulumix.Output[*VolumeAttachmentSpecPatch]{ + OutputState: i.ToVolumeAttachmentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSpec is the specification of a VolumeAttachment request. type VolumeAttachmentSpecPatchOutput struct{ *pulumi.OutputState } @@ -741,6 +850,12 @@ func (o VolumeAttachmentSpecPatchOutput) ToVolumeAttachmentSpecPatchPtrOutputWit }).(VolumeAttachmentSpecPatchPtrOutput) } +func (o VolumeAttachmentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpecPatch] { + return pulumix.Output[VolumeAttachmentSpecPatch]{ + OutputState: o.OutputState, + } +} + // Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). func (o VolumeAttachmentSpecPatchOutput) Attacher() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentSpecPatch) *string { return v.Attacher }).(pulumi.StringPtrOutput) @@ -770,6 +885,12 @@ func (o VolumeAttachmentSpecPatchPtrOutput) ToVolumeAttachmentSpecPatchPtrOutput return o } +func (o VolumeAttachmentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSpecPatch] { + return pulumix.Output[*VolumeAttachmentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentSpecPatchPtrOutput) Elem() VolumeAttachmentSpecPatchOutput { return o.ApplyT(func(v *VolumeAttachmentSpecPatch) VolumeAttachmentSpecPatch { if v != nil { @@ -857,6 +978,12 @@ func (i VolumeAttachmentStatusArgs) ToVolumeAttachmentStatusOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusOutput) } +func (i VolumeAttachmentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatus] { + return pulumix.Output[VolumeAttachmentStatus]{ + OutputState: i.ToVolumeAttachmentStatusOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentStatusArgs) ToVolumeAttachmentStatusPtrOutput() VolumeAttachmentStatusPtrOutput { return i.ToVolumeAttachmentStatusPtrOutputWithContext(context.Background()) } @@ -898,6 +1025,12 @@ func (i *volumeAttachmentStatusPtrType) ToVolumeAttachmentStatusPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPtrOutput) } +func (i *volumeAttachmentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatus] { + return pulumix.Output[*VolumeAttachmentStatus]{ + OutputState: i.ToVolumeAttachmentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentStatus is the status of a VolumeAttachment request. type VolumeAttachmentStatusOutput struct{ *pulumi.OutputState } @@ -923,6 +1056,12 @@ func (o VolumeAttachmentStatusOutput) ToVolumeAttachmentStatusPtrOutputWithConte }).(VolumeAttachmentStatusPtrOutput) } +func (o VolumeAttachmentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatus] { + return pulumix.Output[VolumeAttachmentStatus]{ + OutputState: o.OutputState, + } +} + // The last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. func (o VolumeAttachmentStatusOutput) AttachError() VolumeErrorPtrOutput { return o.ApplyT(func(v VolumeAttachmentStatus) *VolumeError { return v.AttachError }).(VolumeErrorPtrOutput) @@ -957,6 +1096,12 @@ func (o VolumeAttachmentStatusPtrOutput) ToVolumeAttachmentStatusPtrOutputWithCo return o } +func (o VolumeAttachmentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatus] { + return pulumix.Output[*VolumeAttachmentStatus]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentStatusPtrOutput) Elem() VolumeAttachmentStatusOutput { return o.ApplyT(func(v *VolumeAttachmentStatus) VolumeAttachmentStatus { if v != nil { @@ -1054,6 +1199,12 @@ func (i VolumeAttachmentStatusPatchArgs) ToVolumeAttachmentStatusPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPatchOutput) } +func (i VolumeAttachmentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatusPatch] { + return pulumix.Output[VolumeAttachmentStatusPatch]{ + OutputState: i.ToVolumeAttachmentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentStatusPatchArgs) ToVolumeAttachmentStatusPatchPtrOutput() VolumeAttachmentStatusPatchPtrOutput { return i.ToVolumeAttachmentStatusPatchPtrOutputWithContext(context.Background()) } @@ -1095,6 +1246,12 @@ func (i *volumeAttachmentStatusPatchPtrType) ToVolumeAttachmentStatusPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPatchPtrOutput) } +func (i *volumeAttachmentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatusPatch] { + return pulumix.Output[*VolumeAttachmentStatusPatch]{ + OutputState: i.ToVolumeAttachmentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentStatus is the status of a VolumeAttachment request. type VolumeAttachmentStatusPatchOutput struct{ *pulumi.OutputState } @@ -1120,6 +1277,12 @@ func (o VolumeAttachmentStatusPatchOutput) ToVolumeAttachmentStatusPatchPtrOutpu }).(VolumeAttachmentStatusPatchPtrOutput) } +func (o VolumeAttachmentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatusPatch] { + return pulumix.Output[VolumeAttachmentStatusPatch]{ + OutputState: o.OutputState, + } +} + // The last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. func (o VolumeAttachmentStatusPatchOutput) AttachError() VolumeErrorPatchPtrOutput { return o.ApplyT(func(v VolumeAttachmentStatusPatch) *VolumeErrorPatch { return v.AttachError }).(VolumeErrorPatchPtrOutput) @@ -1154,6 +1317,12 @@ func (o VolumeAttachmentStatusPatchPtrOutput) ToVolumeAttachmentStatusPatchPtrOu return o } +func (o VolumeAttachmentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatusPatch] { + return pulumix.Output[*VolumeAttachmentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentStatusPatchPtrOutput) Elem() VolumeAttachmentStatusPatchOutput { return o.ApplyT(func(v *VolumeAttachmentStatusPatch) VolumeAttachmentStatusPatch { if v != nil { @@ -1243,6 +1412,12 @@ func (i VolumeErrorArgs) ToVolumeErrorOutputWithContext(ctx context.Context) Vol return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorOutput) } +func (i VolumeErrorArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeError] { + return pulumix.Output[VolumeError]{ + OutputState: i.ToVolumeErrorOutputWithContext(ctx).OutputState, + } +} + func (i VolumeErrorArgs) ToVolumeErrorPtrOutput() VolumeErrorPtrOutput { return i.ToVolumeErrorPtrOutputWithContext(context.Background()) } @@ -1284,6 +1459,12 @@ func (i *volumeErrorPtrType) ToVolumeErrorPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPtrOutput) } +func (i *volumeErrorPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeError] { + return pulumix.Output[*VolumeError]{ + OutputState: i.ToVolumeErrorPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeError captures an error encountered during a volume operation. type VolumeErrorOutput struct{ *pulumi.OutputState } @@ -1309,6 +1490,12 @@ func (o VolumeErrorOutput) ToVolumeErrorPtrOutputWithContext(ctx context.Context }).(VolumeErrorPtrOutput) } +func (o VolumeErrorOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeError] { + return pulumix.Output[VolumeError]{ + OutputState: o.OutputState, + } +} + // String detailing the error encountered during Attach or Detach operation. This string maybe logged, so it should not contain sensitive information. func (o VolumeErrorOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeError) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -1333,6 +1520,12 @@ func (o VolumeErrorPtrOutput) ToVolumeErrorPtrOutputWithContext(ctx context.Cont return o } +func (o VolumeErrorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeError] { + return pulumix.Output[*VolumeError]{ + OutputState: o.OutputState, + } +} + func (o VolumeErrorPtrOutput) Elem() VolumeErrorOutput { return o.ApplyT(func(v *VolumeError) VolumeError { if v != nil { @@ -1402,6 +1595,12 @@ func (i VolumeErrorPatchArgs) ToVolumeErrorPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPatchOutput) } +func (i VolumeErrorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeErrorPatch] { + return pulumix.Output[VolumeErrorPatch]{ + OutputState: i.ToVolumeErrorPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeErrorPatchArgs) ToVolumeErrorPatchPtrOutput() VolumeErrorPatchPtrOutput { return i.ToVolumeErrorPatchPtrOutputWithContext(context.Background()) } @@ -1443,6 +1642,12 @@ func (i *volumeErrorPatchPtrType) ToVolumeErrorPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPatchPtrOutput) } +func (i *volumeErrorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeErrorPatch] { + return pulumix.Output[*VolumeErrorPatch]{ + OutputState: i.ToVolumeErrorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeError captures an error encountered during a volume operation. type VolumeErrorPatchOutput struct{ *pulumi.OutputState } @@ -1468,6 +1673,12 @@ func (o VolumeErrorPatchOutput) ToVolumeErrorPatchPtrOutputWithContext(ctx conte }).(VolumeErrorPatchPtrOutput) } +func (o VolumeErrorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeErrorPatch] { + return pulumix.Output[VolumeErrorPatch]{ + OutputState: o.OutputState, + } +} + // String detailing the error encountered during Attach or Detach operation. This string maybe logged, so it should not contain sensitive information. func (o VolumeErrorPatchOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeErrorPatch) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -1492,6 +1703,12 @@ func (o VolumeErrorPatchPtrOutput) ToVolumeErrorPatchPtrOutputWithContext(ctx co return o } +func (o VolumeErrorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeErrorPatch] { + return pulumix.Output[*VolumeErrorPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeErrorPatchPtrOutput) Elem() VolumeErrorPatchOutput { return o.ApplyT(func(v *VolumeErrorPatch) VolumeErrorPatch { if v != nil { diff --git a/sdk/go/kubernetes/storage/v1alpha1/volumeAttachment.go b/sdk/go/kubernetes/storage/v1alpha1/volumeAttachment.go index 7e624a3611..ad065b4534 100644 --- a/sdk/go/kubernetes/storage/v1alpha1/volumeAttachment.go +++ b/sdk/go/kubernetes/storage/v1alpha1/volumeAttachment.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. @@ -130,6 +131,12 @@ func (i *VolumeAttachment) ToVolumeAttachmentOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentOutput) } +func (i *VolumeAttachment) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachment] { + return pulumix.Output[*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentArrayInput is an input type that accepts VolumeAttachmentArray and VolumeAttachmentArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentArrayInput` via: // @@ -155,6 +162,12 @@ func (i VolumeAttachmentArray) ToVolumeAttachmentArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentArrayOutput) } +func (i VolumeAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachment] { + return pulumix.Output[[]*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentMapInput is an input type that accepts VolumeAttachmentMap and VolumeAttachmentMapOutput values. // You can construct a concrete instance of `VolumeAttachmentMapInput` via: // @@ -180,6 +193,12 @@ func (i VolumeAttachmentMap) ToVolumeAttachmentMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentMapOutput) } +func (i VolumeAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachment] { + return pulumix.Output[map[string]*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentOutput struct{ *pulumi.OutputState } func (VolumeAttachmentOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o VolumeAttachmentOutput) ToVolumeAttachmentOutputWithContext(ctx context. return o } +func (o VolumeAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachment] { + return pulumix.Output[*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *VolumeAttachment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -233,6 +258,12 @@ func (o VolumeAttachmentArrayOutput) ToVolumeAttachmentArrayOutputWithContext(ct return o } +func (o VolumeAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachment] { + return pulumix.Output[[]*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachment { return vs[0].([]*VolumeAttachment)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o VolumeAttachmentMapOutput) ToVolumeAttachmentMapOutputWithContext(ctx co return o } +func (o VolumeAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachment] { + return pulumix.Output[map[string]*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachment { return vs[0].(map[string]*VolumeAttachment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentList.go b/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentList.go index 6b158c3304..5604bac3e7 100644 --- a/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentList.go +++ b/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // VolumeAttachmentList is a collection of VolumeAttachment objects. @@ -117,6 +118,12 @@ func (i *VolumeAttachmentList) ToVolumeAttachmentListOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListOutput) } +func (i *VolumeAttachmentList) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentList] { + return pulumix.Output[*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentListArrayInput is an input type that accepts VolumeAttachmentListArray and VolumeAttachmentListArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i VolumeAttachmentListArray) ToVolumeAttachmentListArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListArrayOutput) } +func (i VolumeAttachmentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentList] { + return pulumix.Output[[]*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentListMapInput is an input type that accepts VolumeAttachmentListMap and VolumeAttachmentListMapOutput values. // You can construct a concrete instance of `VolumeAttachmentListMapInput` via: // @@ -167,6 +180,12 @@ func (i VolumeAttachmentListMap) ToVolumeAttachmentListMapOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListMapOutput) } +func (i VolumeAttachmentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentList] { + return pulumix.Output[map[string]*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentListOutput struct{ *pulumi.OutputState } func (VolumeAttachmentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o VolumeAttachmentListOutput) ToVolumeAttachmentListOutputWithContext(ctx return o } +func (o VolumeAttachmentListOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentList] { + return pulumix.Output[*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *VolumeAttachmentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o VolumeAttachmentListArrayOutput) ToVolumeAttachmentListArrayOutputWithCo return o } +func (o VolumeAttachmentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentList] { + return pulumix.Output[[]*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentListArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachmentList { return vs[0].([]*VolumeAttachmentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o VolumeAttachmentListMapOutput) ToVolumeAttachmentListMapOutputWithContex return o } +func (o VolumeAttachmentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentList] { + return pulumix.Output[map[string]*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentListMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachmentList { return vs[0].(map[string]*VolumeAttachmentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentPatch.go b/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentPatch.go index 080eade2a9..e98e294312 100644 --- a/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentPatch.go +++ b/sdk/go/kubernetes/storage/v1alpha1/volumeAttachmentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *VolumeAttachmentPatch) ToVolumeAttachmentPatchOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchOutput) } +func (i *VolumeAttachmentPatch) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentPatch] { + return pulumix.Output[*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentPatchArrayInput is an input type that accepts VolumeAttachmentPatchArray and VolumeAttachmentPatchArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i VolumeAttachmentPatchArray) ToVolumeAttachmentPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchArrayOutput) } +func (i VolumeAttachmentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentPatch] { + return pulumix.Output[[]*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentPatchMapInput is an input type that accepts VolumeAttachmentPatchMap and VolumeAttachmentPatchMapOutput values. // You can construct a concrete instance of `VolumeAttachmentPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i VolumeAttachmentPatchMap) ToVolumeAttachmentPatchMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchMapOutput) } +func (i VolumeAttachmentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentPatch] { + return pulumix.Output[map[string]*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentPatchOutput struct{ *pulumi.OutputState } func (VolumeAttachmentPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o VolumeAttachmentPatchOutput) ToVolumeAttachmentPatchOutputWithContext(ct return o } +func (o VolumeAttachmentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentPatch] { + return pulumix.Output[*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *VolumeAttachmentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o VolumeAttachmentPatchArrayOutput) ToVolumeAttachmentPatchArrayOutputWith return o } +func (o VolumeAttachmentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentPatch] { + return pulumix.Output[[]*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentPatchArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachmentPatch { return vs[0].([]*VolumeAttachmentPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o VolumeAttachmentPatchMapOutput) ToVolumeAttachmentPatchMapOutputWithCont return o } +func (o VolumeAttachmentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentPatch] { + return pulumix.Output[map[string]*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentPatchMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachmentPatch { return vs[0].(map[string]*VolumeAttachmentPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csidriver.go b/sdk/go/kubernetes/storage/v1beta1/csidriver.go index 0ffcd6ebe5..64b319e8c5 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csidriver.go +++ b/sdk/go/kubernetes/storage/v1beta1/csidriver.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. CSI drivers do not need to create the CSIDriver object directly. Instead they may use the cluster-driver-registrar sidecar container. When deployed with a CSI driver it automatically creates a CSIDriver object representing the driver. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. @@ -123,6 +124,12 @@ func (i *CSIDriver) ToCSIDriverOutputWithContext(ctx context.Context) CSIDriverO return pulumi.ToOutputWithContext(ctx, i).(CSIDriverOutput) } +func (i *CSIDriver) ToOutput(ctx context.Context) pulumix.Output[*CSIDriver] { + return pulumix.Output[*CSIDriver]{ + OutputState: i.ToCSIDriverOutputWithContext(ctx).OutputState, + } +} + // CSIDriverArrayInput is an input type that accepts CSIDriverArray and CSIDriverArrayOutput values. // You can construct a concrete instance of `CSIDriverArrayInput` via: // @@ -148,6 +155,12 @@ func (i CSIDriverArray) ToCSIDriverArrayOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CSIDriverArrayOutput) } +func (i CSIDriverArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriver] { + return pulumix.Output[[]*CSIDriver]{ + OutputState: i.ToCSIDriverArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriverMapInput is an input type that accepts CSIDriverMap and CSIDriverMapOutput values. // You can construct a concrete instance of `CSIDriverMapInput` via: // @@ -173,6 +186,12 @@ func (i CSIDriverMap) ToCSIDriverMapOutputWithContext(ctx context.Context) CSIDr return pulumi.ToOutputWithContext(ctx, i).(CSIDriverMapOutput) } +func (i CSIDriverMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriver] { + return pulumix.Output[map[string]*CSIDriver]{ + OutputState: i.ToCSIDriverMapOutputWithContext(ctx).OutputState, + } +} + type CSIDriverOutput struct{ *pulumi.OutputState } func (CSIDriverOutput) ElementType() reflect.Type { @@ -187,6 +206,12 @@ func (o CSIDriverOutput) ToCSIDriverOutputWithContext(ctx context.Context) CSIDr return o } +func (o CSIDriverOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriver] { + return pulumix.Output[*CSIDriver]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIDriver) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -221,6 +246,12 @@ func (o CSIDriverArrayOutput) ToCSIDriverArrayOutputWithContext(ctx context.Cont return o } +func (o CSIDriverArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriver] { + return pulumix.Output[[]*CSIDriver]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverArrayOutput) Index(i pulumi.IntInput) CSIDriverOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIDriver { return vs[0].([]*CSIDriver)[vs[1].(int)] @@ -241,6 +272,12 @@ func (o CSIDriverMapOutput) ToCSIDriverMapOutputWithContext(ctx context.Context) return o } +func (o CSIDriverMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriver] { + return pulumix.Output[map[string]*CSIDriver]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverMapOutput) MapIndex(k pulumi.StringInput) CSIDriverOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIDriver { return vs[0].(map[string]*CSIDriver)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csidriverList.go b/sdk/go/kubernetes/storage/v1beta1/csidriverList.go index 6c5782d0b7..2dcf0b3f51 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csidriverList.go +++ b/sdk/go/kubernetes/storage/v1beta1/csidriverList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIDriverList is a collection of CSIDriver objects. @@ -117,6 +118,12 @@ func (i *CSIDriverList) ToCSIDriverListOutputWithContext(ctx context.Context) CS return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListOutput) } +func (i *CSIDriverList) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverList] { + return pulumix.Output[*CSIDriverList]{ + OutputState: i.ToCSIDriverListOutputWithContext(ctx).OutputState, + } +} + // CSIDriverListArrayInput is an input type that accepts CSIDriverListArray and CSIDriverListArrayOutput values. // You can construct a concrete instance of `CSIDriverListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CSIDriverListArray) ToCSIDriverListArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListArrayOutput) } +func (i CSIDriverListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverList] { + return pulumix.Output[[]*CSIDriverList]{ + OutputState: i.ToCSIDriverListArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriverListMapInput is an input type that accepts CSIDriverListMap and CSIDriverListMapOutput values. // You can construct a concrete instance of `CSIDriverListMapInput` via: // @@ -167,6 +180,12 @@ func (i CSIDriverListMap) ToCSIDriverListMapOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListMapOutput) } +func (i CSIDriverListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverList] { + return pulumix.Output[map[string]*CSIDriverList]{ + OutputState: i.ToCSIDriverListMapOutputWithContext(ctx).OutputState, + } +} + type CSIDriverListOutput struct{ *pulumi.OutputState } func (CSIDriverListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CSIDriverListOutput) ToCSIDriverListOutputWithContext(ctx context.Contex return o } +func (o CSIDriverListOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverList] { + return pulumix.Output[*CSIDriverList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIDriverList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CSIDriverListArrayOutput) ToCSIDriverListArrayOutputWithContext(ctx cont return o } +func (o CSIDriverListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverList] { + return pulumix.Output[[]*CSIDriverList]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverListArrayOutput) Index(i pulumi.IntInput) CSIDriverListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIDriverList { return vs[0].([]*CSIDriverList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CSIDriverListMapOutput) ToCSIDriverListMapOutputWithContext(ctx context. return o } +func (o CSIDriverListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverList] { + return pulumix.Output[map[string]*CSIDriverList]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverListMapOutput) MapIndex(k pulumi.StringInput) CSIDriverListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIDriverList { return vs[0].(map[string]*CSIDriverList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csidriverPatch.go b/sdk/go/kubernetes/storage/v1beta1/csidriverPatch.go index 12fdc99ca9..bdc44d1679 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csidriverPatch.go +++ b/sdk/go/kubernetes/storage/v1beta1/csidriverPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -125,6 +126,12 @@ func (i *CSIDriverPatch) ToCSIDriverPatchOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchOutput) } +func (i *CSIDriverPatch) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverPatch] { + return pulumix.Output[*CSIDriverPatch]{ + OutputState: i.ToCSIDriverPatchOutputWithContext(ctx).OutputState, + } +} + // CSIDriverPatchArrayInput is an input type that accepts CSIDriverPatchArray and CSIDriverPatchArrayOutput values. // You can construct a concrete instance of `CSIDriverPatchArrayInput` via: // @@ -150,6 +157,12 @@ func (i CSIDriverPatchArray) ToCSIDriverPatchArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchArrayOutput) } +func (i CSIDriverPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverPatch] { + return pulumix.Output[[]*CSIDriverPatch]{ + OutputState: i.ToCSIDriverPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriverPatchMapInput is an input type that accepts CSIDriverPatchMap and CSIDriverPatchMapOutput values. // You can construct a concrete instance of `CSIDriverPatchMapInput` via: // @@ -175,6 +188,12 @@ func (i CSIDriverPatchMap) ToCSIDriverPatchMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchMapOutput) } +func (i CSIDriverPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverPatch] { + return pulumix.Output[map[string]*CSIDriverPatch]{ + OutputState: i.ToCSIDriverPatchMapOutputWithContext(ctx).OutputState, + } +} + type CSIDriverPatchOutput struct{ *pulumi.OutputState } func (CSIDriverPatchOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o CSIDriverPatchOutput) ToCSIDriverPatchOutputWithContext(ctx context.Cont return o } +func (o CSIDriverPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverPatch] { + return pulumix.Output[*CSIDriverPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CSIDriverPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -223,6 +248,12 @@ func (o CSIDriverPatchArrayOutput) ToCSIDriverPatchArrayOutputWithContext(ctx co return o } +func (o CSIDriverPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIDriverPatch] { + return pulumix.Output[[]*CSIDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverPatchArrayOutput) Index(i pulumi.IntInput) CSIDriverPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIDriverPatch { return vs[0].([]*CSIDriverPatch)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o CSIDriverPatchMapOutput) ToCSIDriverPatchMapOutputWithContext(ctx contex return o } +func (o CSIDriverPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIDriverPatch] { + return pulumix.Output[map[string]*CSIDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverPatchMapOutput) MapIndex(k pulumi.StringInput) CSIDriverPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIDriverPatch { return vs[0].(map[string]*CSIDriverPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csinode.go b/sdk/go/kubernetes/storage/v1beta1/csinode.go index a09b572a4c..c7b3588099 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csinode.go +++ b/sdk/go/kubernetes/storage/v1beta1/csinode.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. @@ -125,6 +126,12 @@ func (i *CSINode) ToCSINodeOutputWithContext(ctx context.Context) CSINodeOutput return pulumi.ToOutputWithContext(ctx, i).(CSINodeOutput) } +func (i *CSINode) ToOutput(ctx context.Context) pulumix.Output[*CSINode] { + return pulumix.Output[*CSINode]{ + OutputState: i.ToCSINodeOutputWithContext(ctx).OutputState, + } +} + // CSINodeArrayInput is an input type that accepts CSINodeArray and CSINodeArrayOutput values. // You can construct a concrete instance of `CSINodeArrayInput` via: // @@ -150,6 +157,12 @@ func (i CSINodeArray) ToCSINodeArrayOutputWithContext(ctx context.Context) CSINo return pulumi.ToOutputWithContext(ctx, i).(CSINodeArrayOutput) } +func (i CSINodeArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSINode] { + return pulumix.Output[[]*CSINode]{ + OutputState: i.ToCSINodeArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeMapInput is an input type that accepts CSINodeMap and CSINodeMapOutput values. // You can construct a concrete instance of `CSINodeMapInput` via: // @@ -175,6 +188,12 @@ func (i CSINodeMap) ToCSINodeMapOutputWithContext(ctx context.Context) CSINodeMa return pulumi.ToOutputWithContext(ctx, i).(CSINodeMapOutput) } +func (i CSINodeMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINode] { + return pulumix.Output[map[string]*CSINode]{ + OutputState: i.ToCSINodeMapOutputWithContext(ctx).OutputState, + } +} + type CSINodeOutput struct{ *pulumi.OutputState } func (CSINodeOutput) ElementType() reflect.Type { @@ -189,6 +208,12 @@ func (o CSINodeOutput) ToCSINodeOutputWithContext(ctx context.Context) CSINodeOu return o } +func (o CSINodeOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINode] { + return pulumix.Output[*CSINode]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSINode) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -223,6 +248,12 @@ func (o CSINodeArrayOutput) ToCSINodeArrayOutputWithContext(ctx context.Context) return o } +func (o CSINodeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSINode] { + return pulumix.Output[[]*CSINode]{ + OutputState: o.OutputState, + } +} + func (o CSINodeArrayOutput) Index(i pulumi.IntInput) CSINodeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSINode { return vs[0].([]*CSINode)[vs[1].(int)] @@ -243,6 +274,12 @@ func (o CSINodeMapOutput) ToCSINodeMapOutputWithContext(ctx context.Context) CSI return o } +func (o CSINodeMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINode] { + return pulumix.Output[map[string]*CSINode]{ + OutputState: o.OutputState, + } +} + func (o CSINodeMapOutput) MapIndex(k pulumi.StringInput) CSINodeOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSINode { return vs[0].(map[string]*CSINode)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csinodeList.go b/sdk/go/kubernetes/storage/v1beta1/csinodeList.go index b48ed39193..96afec3755 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csinodeList.go +++ b/sdk/go/kubernetes/storage/v1beta1/csinodeList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSINodeList is a collection of CSINode objects. @@ -117,6 +118,12 @@ func (i *CSINodeList) ToCSINodeListOutputWithContext(ctx context.Context) CSINod return pulumi.ToOutputWithContext(ctx, i).(CSINodeListOutput) } +func (i *CSINodeList) ToOutput(ctx context.Context) pulumix.Output[*CSINodeList] { + return pulumix.Output[*CSINodeList]{ + OutputState: i.ToCSINodeListOutputWithContext(ctx).OutputState, + } +} + // CSINodeListArrayInput is an input type that accepts CSINodeListArray and CSINodeListArrayOutput values. // You can construct a concrete instance of `CSINodeListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CSINodeListArray) ToCSINodeListArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CSINodeListArrayOutput) } +func (i CSINodeListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodeList] { + return pulumix.Output[[]*CSINodeList]{ + OutputState: i.ToCSINodeListArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeListMapInput is an input type that accepts CSINodeListMap and CSINodeListMapOutput values. // You can construct a concrete instance of `CSINodeListMapInput` via: // @@ -167,6 +180,12 @@ func (i CSINodeListMap) ToCSINodeListMapOutputWithContext(ctx context.Context) C return pulumi.ToOutputWithContext(ctx, i).(CSINodeListMapOutput) } +func (i CSINodeListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodeList] { + return pulumix.Output[map[string]*CSINodeList]{ + OutputState: i.ToCSINodeListMapOutputWithContext(ctx).OutputState, + } +} + type CSINodeListOutput struct{ *pulumi.OutputState } func (CSINodeListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CSINodeListOutput) ToCSINodeListOutputWithContext(ctx context.Context) C return o } +func (o CSINodeListOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINodeList] { + return pulumix.Output[*CSINodeList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSINodeList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CSINodeListArrayOutput) ToCSINodeListArrayOutputWithContext(ctx context. return o } +func (o CSINodeListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodeList] { + return pulumix.Output[[]*CSINodeList]{ + OutputState: o.OutputState, + } +} + func (o CSINodeListArrayOutput) Index(i pulumi.IntInput) CSINodeListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSINodeList { return vs[0].([]*CSINodeList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CSINodeListMapOutput) ToCSINodeListMapOutputWithContext(ctx context.Cont return o } +func (o CSINodeListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodeList] { + return pulumix.Output[map[string]*CSINodeList]{ + OutputState: o.OutputState, + } +} + func (o CSINodeListMapOutput) MapIndex(k pulumi.StringInput) CSINodeListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSINodeList { return vs[0].(map[string]*CSINodeList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csinodePatch.go b/sdk/go/kubernetes/storage/v1beta1/csinodePatch.go index 7622fc9e65..c76b2c9cf9 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csinodePatch.go +++ b/sdk/go/kubernetes/storage/v1beta1/csinodePatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -127,6 +128,12 @@ func (i *CSINodePatch) ToCSINodePatchOutputWithContext(ctx context.Context) CSIN return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchOutput) } +func (i *CSINodePatch) ToOutput(ctx context.Context) pulumix.Output[*CSINodePatch] { + return pulumix.Output[*CSINodePatch]{ + OutputState: i.ToCSINodePatchOutputWithContext(ctx).OutputState, + } +} + // CSINodePatchArrayInput is an input type that accepts CSINodePatchArray and CSINodePatchArrayOutput values. // You can construct a concrete instance of `CSINodePatchArrayInput` via: // @@ -152,6 +159,12 @@ func (i CSINodePatchArray) ToCSINodePatchArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchArrayOutput) } +func (i CSINodePatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodePatch] { + return pulumix.Output[[]*CSINodePatch]{ + OutputState: i.ToCSINodePatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodePatchMapInput is an input type that accepts CSINodePatchMap and CSINodePatchMapOutput values. // You can construct a concrete instance of `CSINodePatchMapInput` via: // @@ -177,6 +190,12 @@ func (i CSINodePatchMap) ToCSINodePatchMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchMapOutput) } +func (i CSINodePatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodePatch] { + return pulumix.Output[map[string]*CSINodePatch]{ + OutputState: i.ToCSINodePatchMapOutputWithContext(ctx).OutputState, + } +} + type CSINodePatchOutput struct{ *pulumi.OutputState } func (CSINodePatchOutput) ElementType() reflect.Type { @@ -191,6 +210,12 @@ func (o CSINodePatchOutput) ToCSINodePatchOutputWithContext(ctx context.Context) return o } +func (o CSINodePatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINodePatch] { + return pulumix.Output[*CSINodePatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodePatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CSINodePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -225,6 +250,12 @@ func (o CSINodePatchArrayOutput) ToCSINodePatchArrayOutputWithContext(ctx contex return o } +func (o CSINodePatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSINodePatch] { + return pulumix.Output[[]*CSINodePatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodePatchArrayOutput) Index(i pulumi.IntInput) CSINodePatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSINodePatch { return vs[0].([]*CSINodePatch)[vs[1].(int)] @@ -245,6 +276,12 @@ func (o CSINodePatchMapOutput) ToCSINodePatchMapOutputWithContext(ctx context.Co return o } +func (o CSINodePatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSINodePatch] { + return pulumix.Output[map[string]*CSINodePatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodePatchMapOutput) MapIndex(k pulumi.StringInput) CSINodePatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSINodePatch { return vs[0].(map[string]*CSINodePatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csistorageCapacity.go b/sdk/go/kubernetes/storage/v1beta1/csistorageCapacity.go index 2297da7f94..9943bd707d 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csistorageCapacity.go +++ b/sdk/go/kubernetes/storage/v1beta1/csistorageCapacity.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. @@ -176,6 +177,12 @@ func (i *CSIStorageCapacity) ToCSIStorageCapacityOutputWithContext(ctx context.C return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityOutput) } +func (i *CSIStorageCapacity) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacity] { + return pulumix.Output[*CSIStorageCapacity]{ + OutputState: i.ToCSIStorageCapacityOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityArrayInput is an input type that accepts CSIStorageCapacityArray and CSIStorageCapacityArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityArrayInput` via: // @@ -201,6 +208,12 @@ func (i CSIStorageCapacityArray) ToCSIStorageCapacityArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityArrayOutput) } +func (i CSIStorageCapacityArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacity] { + return pulumix.Output[[]*CSIStorageCapacity]{ + OutputState: i.ToCSIStorageCapacityArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityMapInput is an input type that accepts CSIStorageCapacityMap and CSIStorageCapacityMapOutput values. // You can construct a concrete instance of `CSIStorageCapacityMapInput` via: // @@ -226,6 +239,12 @@ func (i CSIStorageCapacityMap) ToCSIStorageCapacityMapOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityMapOutput) } +func (i CSIStorageCapacityMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacity] { + return pulumix.Output[map[string]*CSIStorageCapacity]{ + OutputState: i.ToCSIStorageCapacityMapOutputWithContext(ctx).OutputState, + } +} + type CSIStorageCapacityOutput struct{ *pulumi.OutputState } func (CSIStorageCapacityOutput) ElementType() reflect.Type { @@ -240,6 +259,12 @@ func (o CSIStorageCapacityOutput) ToCSIStorageCapacityOutputWithContext(ctx cont return o } +func (o CSIStorageCapacityOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacity] { + return pulumix.Output[*CSIStorageCapacity]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIStorageCapacity) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -297,6 +322,12 @@ func (o CSIStorageCapacityArrayOutput) ToCSIStorageCapacityArrayOutputWithContex return o } +func (o CSIStorageCapacityArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacity] { + return pulumix.Output[[]*CSIStorageCapacity]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIStorageCapacity { return vs[0].([]*CSIStorageCapacity)[vs[1].(int)] @@ -317,6 +348,12 @@ func (o CSIStorageCapacityMapOutput) ToCSIStorageCapacityMapOutputWithContext(ct return o } +func (o CSIStorageCapacityMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacity] { + return pulumix.Output[map[string]*CSIStorageCapacity]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityMapOutput) MapIndex(k pulumi.StringInput) CSIStorageCapacityOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIStorageCapacity { return vs[0].(map[string]*CSIStorageCapacity)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityList.go b/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityList.go index 6c028dcaa0..54619c988a 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityList.go +++ b/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // CSIStorageCapacityList is a collection of CSIStorageCapacity objects. @@ -117,6 +118,12 @@ func (i *CSIStorageCapacityList) ToCSIStorageCapacityListOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListOutput) } +func (i *CSIStorageCapacityList) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityList] { + return pulumix.Output[*CSIStorageCapacityList]{ + OutputState: i.ToCSIStorageCapacityListOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityListArrayInput is an input type that accepts CSIStorageCapacityListArray and CSIStorageCapacityListArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityListArrayInput` via: // @@ -142,6 +149,12 @@ func (i CSIStorageCapacityListArray) ToCSIStorageCapacityListArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListArrayOutput) } +func (i CSIStorageCapacityListArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityList] { + return pulumix.Output[[]*CSIStorageCapacityList]{ + OutputState: i.ToCSIStorageCapacityListArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityListMapInput is an input type that accepts CSIStorageCapacityListMap and CSIStorageCapacityListMapOutput values. // You can construct a concrete instance of `CSIStorageCapacityListMapInput` via: // @@ -167,6 +180,12 @@ func (i CSIStorageCapacityListMap) ToCSIStorageCapacityListMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListMapOutput) } +func (i CSIStorageCapacityListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityList] { + return pulumix.Output[map[string]*CSIStorageCapacityList]{ + OutputState: i.ToCSIStorageCapacityListMapOutputWithContext(ctx).OutputState, + } +} + type CSIStorageCapacityListOutput struct{ *pulumi.OutputState } func (CSIStorageCapacityListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o CSIStorageCapacityListOutput) ToCSIStorageCapacityListOutputWithContext( return o } +func (o CSIStorageCapacityListOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityList] { + return pulumix.Output[*CSIStorageCapacityList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *CSIStorageCapacityList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o CSIStorageCapacityListArrayOutput) ToCSIStorageCapacityListArrayOutputWi return o } +func (o CSIStorageCapacityListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityList] { + return pulumix.Output[[]*CSIStorageCapacityList]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityListArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIStorageCapacityList { return vs[0].([]*CSIStorageCapacityList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o CSIStorageCapacityListMapOutput) ToCSIStorageCapacityListMapOutputWithCo return o } +func (o CSIStorageCapacityListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityList] { + return pulumix.Output[map[string]*CSIStorageCapacityList]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityListMapOutput) MapIndex(k pulumi.StringInput) CSIStorageCapacityListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIStorageCapacityList { return vs[0].(map[string]*CSIStorageCapacityList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityPatch.go b/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityPatch.go index 8dffe60a9a..708ab800fe 100644 --- a/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityPatch.go +++ b/sdk/go/kubernetes/storage/v1beta1/csistorageCapacityPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -178,6 +179,12 @@ func (i *CSIStorageCapacityPatch) ToCSIStorageCapacityPatchOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchOutput) } +func (i *CSIStorageCapacityPatch) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityPatch] { + return pulumix.Output[*CSIStorageCapacityPatch]{ + OutputState: i.ToCSIStorageCapacityPatchOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityPatchArrayInput is an input type that accepts CSIStorageCapacityPatchArray and CSIStorageCapacityPatchArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityPatchArrayInput` via: // @@ -203,6 +210,12 @@ func (i CSIStorageCapacityPatchArray) ToCSIStorageCapacityPatchArrayOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchArrayOutput) } +func (i CSIStorageCapacityPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityPatch] { + return pulumix.Output[[]*CSIStorageCapacityPatch]{ + OutputState: i.ToCSIStorageCapacityPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityPatchMapInput is an input type that accepts CSIStorageCapacityPatchMap and CSIStorageCapacityPatchMapOutput values. // You can construct a concrete instance of `CSIStorageCapacityPatchMapInput` via: // @@ -228,6 +241,12 @@ func (i CSIStorageCapacityPatchMap) ToCSIStorageCapacityPatchMapOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchMapOutput) } +func (i CSIStorageCapacityPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityPatch] { + return pulumix.Output[map[string]*CSIStorageCapacityPatch]{ + OutputState: i.ToCSIStorageCapacityPatchMapOutputWithContext(ctx).OutputState, + } +} + type CSIStorageCapacityPatchOutput struct{ *pulumi.OutputState } func (CSIStorageCapacityPatchOutput) ElementType() reflect.Type { @@ -242,6 +261,12 @@ func (o CSIStorageCapacityPatchOutput) ToCSIStorageCapacityPatchOutputWithContex return o } +func (o CSIStorageCapacityPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIStorageCapacityPatch] { + return pulumix.Output[*CSIStorageCapacityPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *CSIStorageCapacityPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -299,6 +324,12 @@ func (o CSIStorageCapacityPatchArrayOutput) ToCSIStorageCapacityPatchArrayOutput return o } +func (o CSIStorageCapacityPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*CSIStorageCapacityPatch] { + return pulumix.Output[[]*CSIStorageCapacityPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityPatchArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CSIStorageCapacityPatch { return vs[0].([]*CSIStorageCapacityPatch)[vs[1].(int)] @@ -319,6 +350,12 @@ func (o CSIStorageCapacityPatchMapOutput) ToCSIStorageCapacityPatchMapOutputWith return o } +func (o CSIStorageCapacityPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*CSIStorageCapacityPatch] { + return pulumix.Output[map[string]*CSIStorageCapacityPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityPatchMapOutput) MapIndex(k pulumi.StringInput) CSIStorageCapacityPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CSIStorageCapacityPatch { return vs[0].(map[string]*CSIStorageCapacityPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/pulumiTypes.go b/sdk/go/kubernetes/storage/v1beta1/pulumiTypes.go index 3667ade9b9..519329090c 100644 --- a/sdk/go/kubernetes/storage/v1beta1/pulumiTypes.go +++ b/sdk/go/kubernetes/storage/v1beta1/pulumiTypes.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) var _ = internal.GetEnvOrDefault @@ -62,6 +63,12 @@ func (i CSIDriverTypeArgs) ToCSIDriverTypeOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSIDriverTypeOutput) } +func (i CSIDriverTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverType] { + return pulumix.Output[CSIDriverType]{ + OutputState: i.ToCSIDriverTypeOutputWithContext(ctx).OutputState, + } +} + // CSIDriverTypeArrayInput is an input type that accepts CSIDriverTypeArray and CSIDriverTypeArrayOutput values. // You can construct a concrete instance of `CSIDriverTypeArrayInput` via: // @@ -87,6 +94,12 @@ func (i CSIDriverTypeArray) ToCSIDriverTypeArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSIDriverTypeArrayOutput) } +func (i CSIDriverTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CSIDriverType] { + return pulumix.Output[[]CSIDriverType]{ + OutputState: i.ToCSIDriverTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. CSI drivers do not need to create the CSIDriver object directly. Instead they may use the cluster-driver-registrar sidecar container. When deployed with a CSI driver it automatically creates a CSIDriver object representing the driver. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. type CSIDriverTypeOutput struct{ *pulumi.OutputState } @@ -102,6 +115,12 @@ func (o CSIDriverTypeOutput) ToCSIDriverTypeOutputWithContext(ctx context.Contex return o } +func (o CSIDriverTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverType] { + return pulumix.Output[CSIDriverType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIDriverType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -136,6 +155,12 @@ func (o CSIDriverTypeArrayOutput) ToCSIDriverTypeArrayOutputWithContext(ctx cont return o } +func (o CSIDriverTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSIDriverType] { + return pulumix.Output[[]CSIDriverType]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverTypeArrayOutput) Index(i pulumi.IntInput) CSIDriverTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSIDriverType { return vs[0].([]CSIDriverType)[vs[1].(int)] @@ -189,6 +214,12 @@ func (i CSIDriverListTypeArgs) ToCSIDriverListTypeOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(CSIDriverListTypeOutput) } +func (i CSIDriverListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverListType] { + return pulumix.Output[CSIDriverListType]{ + OutputState: i.ToCSIDriverListTypeOutputWithContext(ctx).OutputState, + } +} + // CSIDriverList is a collection of CSIDriver objects. type CSIDriverListTypeOutput struct{ *pulumi.OutputState } @@ -204,6 +235,12 @@ func (o CSIDriverListTypeOutput) ToCSIDriverListTypeOutputWithContext(ctx contex return o } +func (o CSIDriverListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverListType] { + return pulumix.Output[CSIDriverListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIDriverListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -271,6 +308,12 @@ func (i CSIDriverPatchTypeArgs) ToCSIDriverPatchTypeOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CSIDriverPatchTypeOutput) } +func (i CSIDriverPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverPatchType] { + return pulumix.Output[CSIDriverPatchType]{ + OutputState: i.ToCSIDriverPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. CSI drivers do not need to create the CSIDriver object directly. Instead they may use the cluster-driver-registrar sidecar container. When deployed with a CSI driver it automatically creates a CSIDriver object representing the driver. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. type CSIDriverPatchTypeOutput struct{ *pulumi.OutputState } @@ -286,6 +329,12 @@ func (o CSIDriverPatchTypeOutput) ToCSIDriverPatchTypeOutputWithContext(ctx cont return o } +func (o CSIDriverPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverPatchType] { + return pulumix.Output[CSIDriverPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIDriverPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIDriverPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -411,6 +460,12 @@ func (i CSIDriverSpecArgs) ToCSIDriverSpecOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSIDriverSpecOutput) } +func (i CSIDriverSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpec] { + return pulumix.Output[CSIDriverSpec]{ + OutputState: i.ToCSIDriverSpecOutputWithContext(ctx).OutputState, + } +} + // CSIDriverSpec is the specification of a CSIDriver. type CSIDriverSpecOutput struct{ *pulumi.OutputState } @@ -426,6 +481,12 @@ func (o CSIDriverSpecOutput) ToCSIDriverSpecOutputWithContext(ctx context.Contex return o } +func (o CSIDriverSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpec] { + return pulumix.Output[CSIDriverSpec]{ + OutputState: o.OutputState, + } +} + // attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called. func (o CSIDriverSpecOutput) AttachRequired() pulumi.BoolPtrOutput { return o.ApplyT(func(v CSIDriverSpec) *bool { return v.AttachRequired }).(pulumi.BoolPtrOutput) @@ -590,6 +651,12 @@ func (i CSIDriverSpecPatchArgs) ToCSIDriverSpecPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CSIDriverSpecPatchOutput) } +func (i CSIDriverSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpecPatch] { + return pulumix.Output[CSIDriverSpecPatch]{ + OutputState: i.ToCSIDriverSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CSIDriverSpecPatchArgs) ToCSIDriverSpecPatchPtrOutput() CSIDriverSpecPatchPtrOutput { return i.ToCSIDriverSpecPatchPtrOutputWithContext(context.Background()) } @@ -631,6 +698,12 @@ func (i *csidriverSpecPatchPtrType) ToCSIDriverSpecPatchPtrOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSIDriverSpecPatchPtrOutput) } +func (i *csidriverSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverSpecPatch] { + return pulumix.Output[*CSIDriverSpecPatch]{ + OutputState: i.ToCSIDriverSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CSIDriverSpec is the specification of a CSIDriver. type CSIDriverSpecPatchOutput struct{ *pulumi.OutputState } @@ -656,6 +729,12 @@ func (o CSIDriverSpecPatchOutput) ToCSIDriverSpecPatchPtrOutputWithContext(ctx c }).(CSIDriverSpecPatchPtrOutput) } +func (o CSIDriverSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSIDriverSpecPatch] { + return pulumix.Output[CSIDriverSpecPatch]{ + OutputState: o.OutputState, + } +} + // attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called. func (o CSIDriverSpecPatchOutput) AttachRequired() pulumi.BoolPtrOutput { return o.ApplyT(func(v CSIDriverSpecPatch) *bool { return v.AttachRequired }).(pulumi.BoolPtrOutput) @@ -729,6 +808,12 @@ func (o CSIDriverSpecPatchPtrOutput) ToCSIDriverSpecPatchPtrOutputWithContext(ct return o } +func (o CSIDriverSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSIDriverSpecPatch] { + return pulumix.Output[*CSIDriverSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CSIDriverSpecPatchPtrOutput) Elem() CSIDriverSpecPatchOutput { return o.ApplyT(func(v *CSIDriverSpecPatch) CSIDriverSpecPatch { if v != nil { @@ -880,6 +965,12 @@ func (i CSINodeTypeArgs) ToCSINodeTypeOutputWithContext(ctx context.Context) CSI return pulumi.ToOutputWithContext(ctx, i).(CSINodeTypeOutput) } +func (i CSINodeTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeType] { + return pulumix.Output[CSINodeType]{ + OutputState: i.ToCSINodeTypeOutputWithContext(ctx).OutputState, + } +} + // CSINodeTypeArrayInput is an input type that accepts CSINodeTypeArray and CSINodeTypeArrayOutput values. // You can construct a concrete instance of `CSINodeTypeArrayInput` via: // @@ -905,6 +996,12 @@ func (i CSINodeTypeArray) ToCSINodeTypeArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(CSINodeTypeArrayOutput) } +func (i CSINodeTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeType] { + return pulumix.Output[[]CSINodeType]{ + OutputState: i.ToCSINodeTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. type CSINodeTypeOutput struct{ *pulumi.OutputState } @@ -920,6 +1017,12 @@ func (o CSINodeTypeOutput) ToCSINodeTypeOutputWithContext(ctx context.Context) C return o } +func (o CSINodeTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeType] { + return pulumix.Output[CSINodeType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSINodeType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -954,6 +1057,12 @@ func (o CSINodeTypeArrayOutput) ToCSINodeTypeArrayOutputWithContext(ctx context. return o } +func (o CSINodeTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeType] { + return pulumix.Output[[]CSINodeType]{ + OutputState: o.OutputState, + } +} + func (o CSINodeTypeArrayOutput) Index(i pulumi.IntInput) CSINodeTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSINodeType { return vs[0].([]CSINodeType)[vs[1].(int)] @@ -1007,6 +1116,12 @@ func (i CSINodeDriverArgs) ToCSINodeDriverOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverOutput) } +func (i CSINodeDriverArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriver] { + return pulumix.Output[CSINodeDriver]{ + OutputState: i.ToCSINodeDriverOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriverArrayInput is an input type that accepts CSINodeDriverArray and CSINodeDriverArrayOutput values. // You can construct a concrete instance of `CSINodeDriverArrayInput` via: // @@ -1032,6 +1147,12 @@ func (i CSINodeDriverArray) ToCSINodeDriverArrayOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverArrayOutput) } +func (i CSINodeDriverArray) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriver] { + return pulumix.Output[[]CSINodeDriver]{ + OutputState: i.ToCSINodeDriverArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriver holds information about the specification of one CSI driver installed on a node type CSINodeDriverOutput struct{ *pulumi.OutputState } @@ -1047,6 +1168,12 @@ func (o CSINodeDriverOutput) ToCSINodeDriverOutputWithContext(ctx context.Contex return o } +func (o CSINodeDriverOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriver] { + return pulumix.Output[CSINodeDriver]{ + OutputState: o.OutputState, + } +} + // allocatable represents the volume resources of a node that are available for scheduling. func (o CSINodeDriverOutput) Allocatable() VolumeNodeResourcesPtrOutput { return o.ApplyT(func(v CSINodeDriver) *VolumeNodeResources { return v.Allocatable }).(VolumeNodeResourcesPtrOutput) @@ -1081,6 +1208,12 @@ func (o CSINodeDriverArrayOutput) ToCSINodeDriverArrayOutputWithContext(ctx cont return o } +func (o CSINodeDriverArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriver] { + return pulumix.Output[[]CSINodeDriver]{ + OutputState: o.OutputState, + } +} + func (o CSINodeDriverArrayOutput) Index(i pulumi.IntInput) CSINodeDriverOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSINodeDriver { return vs[0].([]CSINodeDriver)[vs[1].(int)] @@ -1134,6 +1267,12 @@ func (i CSINodeDriverPatchArgs) ToCSINodeDriverPatchOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverPatchOutput) } +func (i CSINodeDriverPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriverPatch] { + return pulumix.Output[CSINodeDriverPatch]{ + OutputState: i.ToCSINodeDriverPatchOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriverPatchArrayInput is an input type that accepts CSINodeDriverPatchArray and CSINodeDriverPatchArrayOutput values. // You can construct a concrete instance of `CSINodeDriverPatchArrayInput` via: // @@ -1159,6 +1298,12 @@ func (i CSINodeDriverPatchArray) ToCSINodeDriverPatchArrayOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(CSINodeDriverPatchArrayOutput) } +func (i CSINodeDriverPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriverPatch] { + return pulumix.Output[[]CSINodeDriverPatch]{ + OutputState: i.ToCSINodeDriverPatchArrayOutputWithContext(ctx).OutputState, + } +} + // CSINodeDriver holds information about the specification of one CSI driver installed on a node type CSINodeDriverPatchOutput struct{ *pulumi.OutputState } @@ -1174,6 +1319,12 @@ func (o CSINodeDriverPatchOutput) ToCSINodeDriverPatchOutputWithContext(ctx cont return o } +func (o CSINodeDriverPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeDriverPatch] { + return pulumix.Output[CSINodeDriverPatch]{ + OutputState: o.OutputState, + } +} + // allocatable represents the volume resources of a node that are available for scheduling. func (o CSINodeDriverPatchOutput) Allocatable() VolumeNodeResourcesPatchPtrOutput { return o.ApplyT(func(v CSINodeDriverPatch) *VolumeNodeResourcesPatch { return v.Allocatable }).(VolumeNodeResourcesPatchPtrOutput) @@ -1208,6 +1359,12 @@ func (o CSINodeDriverPatchArrayOutput) ToCSINodeDriverPatchArrayOutputWithContex return o } +func (o CSINodeDriverPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSINodeDriverPatch] { + return pulumix.Output[[]CSINodeDriverPatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodeDriverPatchArrayOutput) Index(i pulumi.IntInput) CSINodeDriverPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSINodeDriverPatch { return vs[0].([]CSINodeDriverPatch)[vs[1].(int)] @@ -1261,6 +1418,12 @@ func (i CSINodeListTypeArgs) ToCSINodeListTypeOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(CSINodeListTypeOutput) } +func (i CSINodeListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeListType] { + return pulumix.Output[CSINodeListType]{ + OutputState: i.ToCSINodeListTypeOutputWithContext(ctx).OutputState, + } +} + // CSINodeList is a collection of CSINode objects. type CSINodeListTypeOutput struct{ *pulumi.OutputState } @@ -1276,6 +1439,12 @@ func (o CSINodeListTypeOutput) ToCSINodeListTypeOutputWithContext(ctx context.Co return o } +func (o CSINodeListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeListType] { + return pulumix.Output[CSINodeListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodeListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSINodeListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1343,6 +1512,12 @@ func (i CSINodePatchTypeArgs) ToCSINodePatchTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSINodePatchTypeOutput) } +func (i CSINodePatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodePatchType] { + return pulumix.Output[CSINodePatchType]{ + OutputState: i.ToCSINodePatchTypeOutputWithContext(ctx).OutputState, + } +} + // CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. type CSINodePatchTypeOutput struct{ *pulumi.OutputState } @@ -1358,6 +1533,12 @@ func (o CSINodePatchTypeOutput) ToCSINodePatchTypeOutputWithContext(ctx context. return o } +func (o CSINodePatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodePatchType] { + return pulumix.Output[CSINodePatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSINodePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSINodePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1413,6 +1594,12 @@ func (i CSINodeSpecArgs) ToCSINodeSpecOutputWithContext(ctx context.Context) CSI return pulumi.ToOutputWithContext(ctx, i).(CSINodeSpecOutput) } +func (i CSINodeSpecArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpec] { + return pulumix.Output[CSINodeSpec]{ + OutputState: i.ToCSINodeSpecOutputWithContext(ctx).OutputState, + } +} + // CSINodeSpec holds information about the specification of all CSI drivers installed on a node type CSINodeSpecOutput struct{ *pulumi.OutputState } @@ -1428,6 +1615,12 @@ func (o CSINodeSpecOutput) ToCSINodeSpecOutputWithContext(ctx context.Context) C return o } +func (o CSINodeSpecOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpec] { + return pulumix.Output[CSINodeSpec]{ + OutputState: o.OutputState, + } +} + // drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. func (o CSINodeSpecOutput) Drivers() CSINodeDriverArrayOutput { return o.ApplyT(func(v CSINodeSpec) []CSINodeDriver { return v.Drivers }).(CSINodeDriverArrayOutput) @@ -1468,6 +1661,12 @@ func (i CSINodeSpecPatchArgs) ToCSINodeSpecPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(CSINodeSpecPatchOutput) } +func (i CSINodeSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpecPatch] { + return pulumix.Output[CSINodeSpecPatch]{ + OutputState: i.ToCSINodeSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i CSINodeSpecPatchArgs) ToCSINodeSpecPatchPtrOutput() CSINodeSpecPatchPtrOutput { return i.ToCSINodeSpecPatchPtrOutputWithContext(context.Background()) } @@ -1509,6 +1708,12 @@ func (i *csinodeSpecPatchPtrType) ToCSINodeSpecPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(CSINodeSpecPatchPtrOutput) } +func (i *csinodeSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*CSINodeSpecPatch] { + return pulumix.Output[*CSINodeSpecPatch]{ + OutputState: i.ToCSINodeSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // CSINodeSpec holds information about the specification of all CSI drivers installed on a node type CSINodeSpecPatchOutput struct{ *pulumi.OutputState } @@ -1534,6 +1739,12 @@ func (o CSINodeSpecPatchOutput) ToCSINodeSpecPatchPtrOutputWithContext(ctx conte }).(CSINodeSpecPatchPtrOutput) } +func (o CSINodeSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[CSINodeSpecPatch] { + return pulumix.Output[CSINodeSpecPatch]{ + OutputState: o.OutputState, + } +} + // drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. func (o CSINodeSpecPatchOutput) Drivers() CSINodeDriverPatchArrayOutput { return o.ApplyT(func(v CSINodeSpecPatch) []CSINodeDriverPatch { return v.Drivers }).(CSINodeDriverPatchArrayOutput) @@ -1553,6 +1764,12 @@ func (o CSINodeSpecPatchPtrOutput) ToCSINodeSpecPatchPtrOutputWithContext(ctx co return o } +func (o CSINodeSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*CSINodeSpecPatch] { + return pulumix.Output[*CSINodeSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o CSINodeSpecPatchPtrOutput) Elem() CSINodeSpecPatchOutput { return o.ApplyT(func(v *CSINodeSpecPatch) CSINodeSpecPatch { if v != nil { @@ -1664,6 +1881,12 @@ func (i CSIStorageCapacityTypeArgs) ToCSIStorageCapacityTypeOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityTypeOutput) } +func (i CSIStorageCapacityTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityType] { + return pulumix.Output[CSIStorageCapacityType]{ + OutputState: i.ToCSIStorageCapacityTypeOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityTypeArrayInput is an input type that accepts CSIStorageCapacityTypeArray and CSIStorageCapacityTypeArrayOutput values. // You can construct a concrete instance of `CSIStorageCapacityTypeArrayInput` via: // @@ -1689,6 +1912,12 @@ func (i CSIStorageCapacityTypeArray) ToCSIStorageCapacityTypeArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityTypeArrayOutput) } +func (i CSIStorageCapacityTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]CSIStorageCapacityType] { + return pulumix.Output[[]CSIStorageCapacityType]{ + OutputState: i.ToCSIStorageCapacityTypeArrayOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. // // For example this can express things like: - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1" - StorageClass "localssd" has "10 GiB" available in "kubernetes.io/hostname=knode-abc123" @@ -1712,6 +1941,12 @@ func (o CSIStorageCapacityTypeOutput) ToCSIStorageCapacityTypeOutputWithContext( return o } +func (o CSIStorageCapacityTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityType] { + return pulumix.Output[CSIStorageCapacityType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIStorageCapacityType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1769,6 +2004,12 @@ func (o CSIStorageCapacityTypeArrayOutput) ToCSIStorageCapacityTypeArrayOutputWi return o } +func (o CSIStorageCapacityTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]CSIStorageCapacityType] { + return pulumix.Output[[]CSIStorageCapacityType]{ + OutputState: o.OutputState, + } +} + func (o CSIStorageCapacityTypeArrayOutput) Index(i pulumi.IntInput) CSIStorageCapacityTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) CSIStorageCapacityType { return vs[0].([]CSIStorageCapacityType)[vs[1].(int)] @@ -1822,6 +2063,12 @@ func (i CSIStorageCapacityListTypeArgs) ToCSIStorageCapacityListTypeOutputWithCo return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityListTypeOutput) } +func (i CSIStorageCapacityListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityListType] { + return pulumix.Output[CSIStorageCapacityListType]{ + OutputState: i.ToCSIStorageCapacityListTypeOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacityList is a collection of CSIStorageCapacity objects. type CSIStorageCapacityListTypeOutput struct{ *pulumi.OutputState } @@ -1837,6 +2084,12 @@ func (o CSIStorageCapacityListTypeOutput) ToCSIStorageCapacityListTypeOutputWith return o } +func (o CSIStorageCapacityListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityListType] { + return pulumix.Output[CSIStorageCapacityListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIStorageCapacityListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -1948,6 +2201,12 @@ func (i CSIStorageCapacityPatchTypeArgs) ToCSIStorageCapacityPatchTypeOutputWith return pulumi.ToOutputWithContext(ctx, i).(CSIStorageCapacityPatchTypeOutput) } +func (i CSIStorageCapacityPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityPatchType] { + return pulumix.Output[CSIStorageCapacityPatchType]{ + OutputState: i.ToCSIStorageCapacityPatchTypeOutputWithContext(ctx).OutputState, + } +} + // CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. // // For example this can express things like: - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1" - StorageClass "localssd" has "10 GiB" available in "kubernetes.io/hostname=knode-abc123" @@ -1971,6 +2230,12 @@ func (o CSIStorageCapacityPatchTypeOutput) ToCSIStorageCapacityPatchTypeOutputWi return o } +func (o CSIStorageCapacityPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[CSIStorageCapacityPatchType] { + return pulumix.Output[CSIStorageCapacityPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o CSIStorageCapacityPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v CSIStorageCapacityPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2089,6 +2354,12 @@ func (i StorageClassTypeArgs) ToStorageClassTypeOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StorageClassTypeOutput) } +func (i StorageClassTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StorageClassType] { + return pulumix.Output[StorageClassType]{ + OutputState: i.ToStorageClassTypeOutputWithContext(ctx).OutputState, + } +} + // StorageClassTypeArrayInput is an input type that accepts StorageClassTypeArray and StorageClassTypeArrayOutput values. // You can construct a concrete instance of `StorageClassTypeArrayInput` via: // @@ -2114,6 +2385,12 @@ func (i StorageClassTypeArray) ToStorageClassTypeArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StorageClassTypeArrayOutput) } +func (i StorageClassTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]StorageClassType] { + return pulumix.Output[[]StorageClassType]{ + OutputState: i.ToStorageClassTypeArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. // // StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. @@ -2131,6 +2408,12 @@ func (o StorageClassTypeOutput) ToStorageClassTypeOutputWithContext(ctx context. return o } +func (o StorageClassTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StorageClassType] { + return pulumix.Output[StorageClassType]{ + OutputState: o.OutputState, + } +} + // AllowVolumeExpansion shows whether the storage class allow volume expand func (o StorageClassTypeOutput) AllowVolumeExpansion() pulumi.BoolPtrOutput { return o.ApplyT(func(v StorageClassType) *bool { return v.AllowVolumeExpansion }).(pulumi.BoolPtrOutput) @@ -2195,6 +2478,12 @@ func (o StorageClassTypeArrayOutput) ToStorageClassTypeArrayOutputWithContext(ct return o } +func (o StorageClassTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]StorageClassType] { + return pulumix.Output[[]StorageClassType]{ + OutputState: o.OutputState, + } +} + func (o StorageClassTypeArrayOutput) Index(i pulumi.IntInput) StorageClassTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) StorageClassType { return vs[0].([]StorageClassType)[vs[1].(int)] @@ -2248,6 +2537,12 @@ func (i StorageClassListTypeArgs) ToStorageClassListTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StorageClassListTypeOutput) } +func (i StorageClassListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StorageClassListType] { + return pulumix.Output[StorageClassListType]{ + OutputState: i.ToStorageClassListTypeOutputWithContext(ctx).OutputState, + } +} + // StorageClassList is a collection of storage classes. type StorageClassListTypeOutput struct{ *pulumi.OutputState } @@ -2263,6 +2558,12 @@ func (o StorageClassListTypeOutput) ToStorageClassListTypeOutputWithContext(ctx return o } +func (o StorageClassListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StorageClassListType] { + return pulumix.Output[StorageClassListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StorageClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v StorageClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2358,6 +2659,12 @@ func (i StorageClassPatchTypeArgs) ToStorageClassPatchTypeOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchTypeOutput) } +func (i StorageClassPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[StorageClassPatchType] { + return pulumix.Output[StorageClassPatchType]{ + OutputState: i.ToStorageClassPatchTypeOutputWithContext(ctx).OutputState, + } +} + // StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. // // StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. @@ -2375,6 +2682,12 @@ func (o StorageClassPatchTypeOutput) ToStorageClassPatchTypeOutputWithContext(ct return o } +func (o StorageClassPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[StorageClassPatchType] { + return pulumix.Output[StorageClassPatchType]{ + OutputState: o.OutputState, + } +} + // AllowVolumeExpansion shows whether the storage class allow volume expand func (o StorageClassPatchTypeOutput) AllowVolumeExpansion() pulumi.BoolPtrOutput { return o.ApplyT(func(v StorageClassPatchType) *bool { return v.AllowVolumeExpansion }).(pulumi.BoolPtrOutput) @@ -2464,6 +2777,12 @@ func (i TokenRequestArgs) ToTokenRequestOutputWithContext(ctx context.Context) T return pulumi.ToOutputWithContext(ctx, i).(TokenRequestOutput) } +func (i TokenRequestArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequest] { + return pulumix.Output[TokenRequest]{ + OutputState: i.ToTokenRequestOutputWithContext(ctx).OutputState, + } +} + // TokenRequestArrayInput is an input type that accepts TokenRequestArray and TokenRequestArrayOutput values. // You can construct a concrete instance of `TokenRequestArrayInput` via: // @@ -2489,6 +2808,12 @@ func (i TokenRequestArray) ToTokenRequestArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(TokenRequestArrayOutput) } +func (i TokenRequestArray) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequest] { + return pulumix.Output[[]TokenRequest]{ + OutputState: i.ToTokenRequestArrayOutputWithContext(ctx).OutputState, + } +} + // TokenRequest contains parameters of a service account token. type TokenRequestOutput struct{ *pulumi.OutputState } @@ -2504,6 +2829,12 @@ func (o TokenRequestOutput) ToTokenRequestOutputWithContext(ctx context.Context) return o } +func (o TokenRequestOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequest] { + return pulumix.Output[TokenRequest]{ + OutputState: o.OutputState, + } +} + // Audience is the intended audience of the token in "TokenRequestSpec". It will default to the audiences of kube apiserver. func (o TokenRequestOutput) Audience() pulumi.StringOutput { return o.ApplyT(func(v TokenRequest) string { return v.Audience }).(pulumi.StringOutput) @@ -2528,6 +2859,12 @@ func (o TokenRequestArrayOutput) ToTokenRequestArrayOutputWithContext(ctx contex return o } +func (o TokenRequestArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequest] { + return pulumix.Output[[]TokenRequest]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestArrayOutput) Index(i pulumi.IntInput) TokenRequestOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TokenRequest { return vs[0].([]TokenRequest)[vs[1].(int)] @@ -2573,6 +2910,12 @@ func (i TokenRequestPatchArgs) ToTokenRequestPatchOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(TokenRequestPatchOutput) } +func (i TokenRequestPatchArgs) ToOutput(ctx context.Context) pulumix.Output[TokenRequestPatch] { + return pulumix.Output[TokenRequestPatch]{ + OutputState: i.ToTokenRequestPatchOutputWithContext(ctx).OutputState, + } +} + // TokenRequestPatchArrayInput is an input type that accepts TokenRequestPatchArray and TokenRequestPatchArrayOutput values. // You can construct a concrete instance of `TokenRequestPatchArrayInput` via: // @@ -2598,6 +2941,12 @@ func (i TokenRequestPatchArray) ToTokenRequestPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(TokenRequestPatchArrayOutput) } +func (i TokenRequestPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequestPatch] { + return pulumix.Output[[]TokenRequestPatch]{ + OutputState: i.ToTokenRequestPatchArrayOutputWithContext(ctx).OutputState, + } +} + // TokenRequest contains parameters of a service account token. type TokenRequestPatchOutput struct{ *pulumi.OutputState } @@ -2613,6 +2962,12 @@ func (o TokenRequestPatchOutput) ToTokenRequestPatchOutputWithContext(ctx contex return o } +func (o TokenRequestPatchOutput) ToOutput(ctx context.Context) pulumix.Output[TokenRequestPatch] { + return pulumix.Output[TokenRequestPatch]{ + OutputState: o.OutputState, + } +} + // Audience is the intended audience of the token in "TokenRequestSpec". It will default to the audiences of kube apiserver. func (o TokenRequestPatchOutput) Audience() pulumi.StringPtrOutput { return o.ApplyT(func(v TokenRequestPatch) *string { return v.Audience }).(pulumi.StringPtrOutput) @@ -2637,6 +2992,12 @@ func (o TokenRequestPatchArrayOutput) ToTokenRequestPatchArrayOutputWithContext( return o } +func (o TokenRequestPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]TokenRequestPatch] { + return pulumix.Output[[]TokenRequestPatch]{ + OutputState: o.OutputState, + } +} + func (o TokenRequestPatchArrayOutput) Index(i pulumi.IntInput) TokenRequestPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) TokenRequestPatch { return vs[0].([]TokenRequestPatch)[vs[1].(int)] @@ -2698,6 +3059,12 @@ func (i VolumeAttachmentTypeArgs) ToVolumeAttachmentTypeOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentTypeOutput) } +func (i VolumeAttachmentTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentType] { + return pulumix.Output[VolumeAttachmentType]{ + OutputState: i.ToVolumeAttachmentTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentTypeArrayInput is an input type that accepts VolumeAttachmentTypeArray and VolumeAttachmentTypeArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentTypeArrayInput` via: // @@ -2723,6 +3090,12 @@ func (i VolumeAttachmentTypeArray) ToVolumeAttachmentTypeArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentTypeArrayOutput) } +func (i VolumeAttachmentTypeArray) ToOutput(ctx context.Context) pulumix.Output[[]VolumeAttachmentType] { + return pulumix.Output[[]VolumeAttachmentType]{ + OutputState: i.ToVolumeAttachmentTypeArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. // // VolumeAttachment objects are non-namespaced. @@ -2740,6 +3113,12 @@ func (o VolumeAttachmentTypeOutput) ToVolumeAttachmentTypeOutputWithContext(ctx return o } +func (o VolumeAttachmentTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentType] { + return pulumix.Output[VolumeAttachmentType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2779,6 +3158,12 @@ func (o VolumeAttachmentTypeArrayOutput) ToVolumeAttachmentTypeArrayOutputWithCo return o } +func (o VolumeAttachmentTypeArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]VolumeAttachmentType] { + return pulumix.Output[[]VolumeAttachmentType]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentTypeArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentTypeOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) VolumeAttachmentType { return vs[0].([]VolumeAttachmentType)[vs[1].(int)] @@ -2832,6 +3217,12 @@ func (i VolumeAttachmentListTypeArgs) ToVolumeAttachmentListTypeOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListTypeOutput) } +func (i VolumeAttachmentListTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentListType] { + return pulumix.Output[VolumeAttachmentListType]{ + OutputState: i.ToVolumeAttachmentListTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentList is a collection of VolumeAttachment objects. type VolumeAttachmentListTypeOutput struct{ *pulumi.OutputState } @@ -2847,6 +3238,12 @@ func (o VolumeAttachmentListTypeOutput) ToVolumeAttachmentListTypeOutputWithCont return o } +func (o VolumeAttachmentListTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentListType] { + return pulumix.Output[VolumeAttachmentListType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentListTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -2922,6 +3319,12 @@ func (i VolumeAttachmentPatchTypeArgs) ToVolumeAttachmentPatchTypeOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchTypeOutput) } +func (i VolumeAttachmentPatchTypeArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentPatchType] { + return pulumix.Output[VolumeAttachmentPatchType]{ + OutputState: i.ToVolumeAttachmentPatchTypeOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. // // VolumeAttachment objects are non-namespaced. @@ -2939,6 +3342,12 @@ func (o VolumeAttachmentPatchTypeOutput) ToVolumeAttachmentPatchTypeOutputWithCo return o } +func (o VolumeAttachmentPatchTypeOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentPatchType] { + return pulumix.Output[VolumeAttachmentPatchType]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -3003,6 +3412,12 @@ func (i VolumeAttachmentSourceArgs) ToVolumeAttachmentSourceOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourceOutput) } +func (i VolumeAttachmentSourceArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSource] { + return pulumix.Output[VolumeAttachmentSource]{ + OutputState: i.ToVolumeAttachmentSourceOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. type VolumeAttachmentSourceOutput struct{ *pulumi.OutputState } @@ -3018,6 +3433,12 @@ func (o VolumeAttachmentSourceOutput) ToVolumeAttachmentSourceOutputWithContext( return o } +func (o VolumeAttachmentSourceOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSource] { + return pulumix.Output[VolumeAttachmentSource]{ + OutputState: o.OutputState, + } +} + // inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is alpha-level and is only honored by servers that enabled the CSIMigration feature. func (o VolumeAttachmentSourceOutput) InlineVolumeSpec() corev1.PersistentVolumeSpecPtrOutput { return o.ApplyT(func(v VolumeAttachmentSource) *corev1.PersistentVolumeSpec { return v.InlineVolumeSpec }).(corev1.PersistentVolumeSpecPtrOutput) @@ -3067,6 +3488,12 @@ func (i VolumeAttachmentSourcePatchArgs) ToVolumeAttachmentSourcePatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourcePatchOutput) } +func (i VolumeAttachmentSourcePatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSourcePatch] { + return pulumix.Output[VolumeAttachmentSourcePatch]{ + OutputState: i.ToVolumeAttachmentSourcePatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentSourcePatchArgs) ToVolumeAttachmentSourcePatchPtrOutput() VolumeAttachmentSourcePatchPtrOutput { return i.ToVolumeAttachmentSourcePatchPtrOutputWithContext(context.Background()) } @@ -3108,6 +3535,12 @@ func (i *volumeAttachmentSourcePatchPtrType) ToVolumeAttachmentSourcePatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSourcePatchPtrOutput) } +func (i *volumeAttachmentSourcePatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSourcePatch] { + return pulumix.Output[*VolumeAttachmentSourcePatch]{ + OutputState: i.ToVolumeAttachmentSourcePatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. type VolumeAttachmentSourcePatchOutput struct{ *pulumi.OutputState } @@ -3133,6 +3566,12 @@ func (o VolumeAttachmentSourcePatchOutput) ToVolumeAttachmentSourcePatchPtrOutpu }).(VolumeAttachmentSourcePatchPtrOutput) } +func (o VolumeAttachmentSourcePatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSourcePatch] { + return pulumix.Output[VolumeAttachmentSourcePatch]{ + OutputState: o.OutputState, + } +} + // inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is alpha-level and is only honored by servers that enabled the CSIMigration feature. func (o VolumeAttachmentSourcePatchOutput) InlineVolumeSpec() corev1.PersistentVolumeSpecPatchPtrOutput { return o.ApplyT(func(v VolumeAttachmentSourcePatch) *corev1.PersistentVolumeSpecPatch { return v.InlineVolumeSpec }).(corev1.PersistentVolumeSpecPatchPtrOutput) @@ -3157,6 +3596,12 @@ func (o VolumeAttachmentSourcePatchPtrOutput) ToVolumeAttachmentSourcePatchPtrOu return o } +func (o VolumeAttachmentSourcePatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSourcePatch] { + return pulumix.Output[*VolumeAttachmentSourcePatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentSourcePatchPtrOutput) Elem() VolumeAttachmentSourcePatchOutput { return o.ApplyT(func(v *VolumeAttachmentSourcePatch) VolumeAttachmentSourcePatch { if v != nil { @@ -3230,6 +3675,12 @@ func (i VolumeAttachmentSpecArgs) ToVolumeAttachmentSpecOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecOutput) } +func (i VolumeAttachmentSpecArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpec] { + return pulumix.Output[VolumeAttachmentSpec]{ + OutputState: i.ToVolumeAttachmentSpecOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSpec is the specification of a VolumeAttachment request. type VolumeAttachmentSpecOutput struct{ *pulumi.OutputState } @@ -3245,6 +3696,12 @@ func (o VolumeAttachmentSpecOutput) ToVolumeAttachmentSpecOutputWithContext(ctx return o } +func (o VolumeAttachmentSpecOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpec] { + return pulumix.Output[VolumeAttachmentSpec]{ + OutputState: o.OutputState, + } +} + // Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). func (o VolumeAttachmentSpecOutput) Attacher() pulumi.StringOutput { return o.ApplyT(func(v VolumeAttachmentSpec) string { return v.Attacher }).(pulumi.StringOutput) @@ -3303,6 +3760,12 @@ func (i VolumeAttachmentSpecPatchArgs) ToVolumeAttachmentSpecPatchOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecPatchOutput) } +func (i VolumeAttachmentSpecPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpecPatch] { + return pulumix.Output[VolumeAttachmentSpecPatch]{ + OutputState: i.ToVolumeAttachmentSpecPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentSpecPatchArgs) ToVolumeAttachmentSpecPatchPtrOutput() VolumeAttachmentSpecPatchPtrOutput { return i.ToVolumeAttachmentSpecPatchPtrOutputWithContext(context.Background()) } @@ -3344,6 +3807,12 @@ func (i *volumeAttachmentSpecPatchPtrType) ToVolumeAttachmentSpecPatchPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentSpecPatchPtrOutput) } +func (i *volumeAttachmentSpecPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSpecPatch] { + return pulumix.Output[*VolumeAttachmentSpecPatch]{ + OutputState: i.ToVolumeAttachmentSpecPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentSpec is the specification of a VolumeAttachment request. type VolumeAttachmentSpecPatchOutput struct{ *pulumi.OutputState } @@ -3369,6 +3838,12 @@ func (o VolumeAttachmentSpecPatchOutput) ToVolumeAttachmentSpecPatchPtrOutputWit }).(VolumeAttachmentSpecPatchPtrOutput) } +func (o VolumeAttachmentSpecPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentSpecPatch] { + return pulumix.Output[VolumeAttachmentSpecPatch]{ + OutputState: o.OutputState, + } +} + // Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). func (o VolumeAttachmentSpecPatchOutput) Attacher() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeAttachmentSpecPatch) *string { return v.Attacher }).(pulumi.StringPtrOutput) @@ -3398,6 +3873,12 @@ func (o VolumeAttachmentSpecPatchPtrOutput) ToVolumeAttachmentSpecPatchPtrOutput return o } +func (o VolumeAttachmentSpecPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentSpecPatch] { + return pulumix.Output[*VolumeAttachmentSpecPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentSpecPatchPtrOutput) Elem() VolumeAttachmentSpecPatchOutput { return o.ApplyT(func(v *VolumeAttachmentSpecPatch) VolumeAttachmentSpecPatch { if v != nil { @@ -3485,6 +3966,12 @@ func (i VolumeAttachmentStatusArgs) ToVolumeAttachmentStatusOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusOutput) } +func (i VolumeAttachmentStatusArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatus] { + return pulumix.Output[VolumeAttachmentStatus]{ + OutputState: i.ToVolumeAttachmentStatusOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentStatusArgs) ToVolumeAttachmentStatusPtrOutput() VolumeAttachmentStatusPtrOutput { return i.ToVolumeAttachmentStatusPtrOutputWithContext(context.Background()) } @@ -3526,6 +4013,12 @@ func (i *volumeAttachmentStatusPtrType) ToVolumeAttachmentStatusPtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPtrOutput) } +func (i *volumeAttachmentStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatus] { + return pulumix.Output[*VolumeAttachmentStatus]{ + OutputState: i.ToVolumeAttachmentStatusPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentStatus is the status of a VolumeAttachment request. type VolumeAttachmentStatusOutput struct{ *pulumi.OutputState } @@ -3551,6 +4044,12 @@ func (o VolumeAttachmentStatusOutput) ToVolumeAttachmentStatusPtrOutputWithConte }).(VolumeAttachmentStatusPtrOutput) } +func (o VolumeAttachmentStatusOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatus] { + return pulumix.Output[VolumeAttachmentStatus]{ + OutputState: o.OutputState, + } +} + // The last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. func (o VolumeAttachmentStatusOutput) AttachError() VolumeErrorPtrOutput { return o.ApplyT(func(v VolumeAttachmentStatus) *VolumeError { return v.AttachError }).(VolumeErrorPtrOutput) @@ -3585,6 +4084,12 @@ func (o VolumeAttachmentStatusPtrOutput) ToVolumeAttachmentStatusPtrOutputWithCo return o } +func (o VolumeAttachmentStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatus] { + return pulumix.Output[*VolumeAttachmentStatus]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentStatusPtrOutput) Elem() VolumeAttachmentStatusOutput { return o.ApplyT(func(v *VolumeAttachmentStatus) VolumeAttachmentStatus { if v != nil { @@ -3682,6 +4187,12 @@ func (i VolumeAttachmentStatusPatchArgs) ToVolumeAttachmentStatusPatchOutputWith return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPatchOutput) } +func (i VolumeAttachmentStatusPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatusPatch] { + return pulumix.Output[VolumeAttachmentStatusPatch]{ + OutputState: i.ToVolumeAttachmentStatusPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeAttachmentStatusPatchArgs) ToVolumeAttachmentStatusPatchPtrOutput() VolumeAttachmentStatusPatchPtrOutput { return i.ToVolumeAttachmentStatusPatchPtrOutputWithContext(context.Background()) } @@ -3723,6 +4234,12 @@ func (i *volumeAttachmentStatusPatchPtrType) ToVolumeAttachmentStatusPatchPtrOut return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentStatusPatchPtrOutput) } +func (i *volumeAttachmentStatusPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatusPatch] { + return pulumix.Output[*VolumeAttachmentStatusPatch]{ + OutputState: i.ToVolumeAttachmentStatusPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentStatus is the status of a VolumeAttachment request. type VolumeAttachmentStatusPatchOutput struct{ *pulumi.OutputState } @@ -3748,6 +4265,12 @@ func (o VolumeAttachmentStatusPatchOutput) ToVolumeAttachmentStatusPatchPtrOutpu }).(VolumeAttachmentStatusPatchPtrOutput) } +func (o VolumeAttachmentStatusPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeAttachmentStatusPatch] { + return pulumix.Output[VolumeAttachmentStatusPatch]{ + OutputState: o.OutputState, + } +} + // The last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. func (o VolumeAttachmentStatusPatchOutput) AttachError() VolumeErrorPatchPtrOutput { return o.ApplyT(func(v VolumeAttachmentStatusPatch) *VolumeErrorPatch { return v.AttachError }).(VolumeErrorPatchPtrOutput) @@ -3782,6 +4305,12 @@ func (o VolumeAttachmentStatusPatchPtrOutput) ToVolumeAttachmentStatusPatchPtrOu return o } +func (o VolumeAttachmentStatusPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentStatusPatch] { + return pulumix.Output[*VolumeAttachmentStatusPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentStatusPatchPtrOutput) Elem() VolumeAttachmentStatusPatchOutput { return o.ApplyT(func(v *VolumeAttachmentStatusPatch) VolumeAttachmentStatusPatch { if v != nil { @@ -3871,6 +4400,12 @@ func (i VolumeErrorArgs) ToVolumeErrorOutputWithContext(ctx context.Context) Vol return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorOutput) } +func (i VolumeErrorArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeError] { + return pulumix.Output[VolumeError]{ + OutputState: i.ToVolumeErrorOutputWithContext(ctx).OutputState, + } +} + func (i VolumeErrorArgs) ToVolumeErrorPtrOutput() VolumeErrorPtrOutput { return i.ToVolumeErrorPtrOutputWithContext(context.Background()) } @@ -3912,6 +4447,12 @@ func (i *volumeErrorPtrType) ToVolumeErrorPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPtrOutput) } +func (i *volumeErrorPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeError] { + return pulumix.Output[*VolumeError]{ + OutputState: i.ToVolumeErrorPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeError captures an error encountered during a volume operation. type VolumeErrorOutput struct{ *pulumi.OutputState } @@ -3937,6 +4478,12 @@ func (o VolumeErrorOutput) ToVolumeErrorPtrOutputWithContext(ctx context.Context }).(VolumeErrorPtrOutput) } +func (o VolumeErrorOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeError] { + return pulumix.Output[VolumeError]{ + OutputState: o.OutputState, + } +} + // String detailing the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. func (o VolumeErrorOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeError) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -3961,6 +4508,12 @@ func (o VolumeErrorPtrOutput) ToVolumeErrorPtrOutputWithContext(ctx context.Cont return o } +func (o VolumeErrorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeError] { + return pulumix.Output[*VolumeError]{ + OutputState: o.OutputState, + } +} + func (o VolumeErrorPtrOutput) Elem() VolumeErrorOutput { return o.ApplyT(func(v *VolumeError) VolumeError { if v != nil { @@ -4030,6 +4583,12 @@ func (i VolumeErrorPatchArgs) ToVolumeErrorPatchOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPatchOutput) } +func (i VolumeErrorPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeErrorPatch] { + return pulumix.Output[VolumeErrorPatch]{ + OutputState: i.ToVolumeErrorPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeErrorPatchArgs) ToVolumeErrorPatchPtrOutput() VolumeErrorPatchPtrOutput { return i.ToVolumeErrorPatchPtrOutputWithContext(context.Background()) } @@ -4071,6 +4630,12 @@ func (i *volumeErrorPatchPtrType) ToVolumeErrorPatchPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(VolumeErrorPatchPtrOutput) } +func (i *volumeErrorPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeErrorPatch] { + return pulumix.Output[*VolumeErrorPatch]{ + OutputState: i.ToVolumeErrorPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeError captures an error encountered during a volume operation. type VolumeErrorPatchOutput struct{ *pulumi.OutputState } @@ -4096,6 +4661,12 @@ func (o VolumeErrorPatchOutput) ToVolumeErrorPatchPtrOutputWithContext(ctx conte }).(VolumeErrorPatchPtrOutput) } +func (o VolumeErrorPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeErrorPatch] { + return pulumix.Output[VolumeErrorPatch]{ + OutputState: o.OutputState, + } +} + // String detailing the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. func (o VolumeErrorPatchOutput) Message() pulumi.StringPtrOutput { return o.ApplyT(func(v VolumeErrorPatch) *string { return v.Message }).(pulumi.StringPtrOutput) @@ -4120,6 +4691,12 @@ func (o VolumeErrorPatchPtrOutput) ToVolumeErrorPatchPtrOutputWithContext(ctx co return o } +func (o VolumeErrorPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeErrorPatch] { + return pulumix.Output[*VolumeErrorPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeErrorPatchPtrOutput) Elem() VolumeErrorPatchOutput { return o.ApplyT(func(v *VolumeErrorPatch) VolumeErrorPatch { if v != nil { @@ -4185,6 +4762,12 @@ func (i VolumeNodeResourcesArgs) ToVolumeNodeResourcesOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesOutput) } +func (i VolumeNodeResourcesArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResources] { + return pulumix.Output[VolumeNodeResources]{ + OutputState: i.ToVolumeNodeResourcesOutputWithContext(ctx).OutputState, + } +} + func (i VolumeNodeResourcesArgs) ToVolumeNodeResourcesPtrOutput() VolumeNodeResourcesPtrOutput { return i.ToVolumeNodeResourcesPtrOutputWithContext(context.Background()) } @@ -4226,6 +4809,12 @@ func (i *volumeNodeResourcesPtrType) ToVolumeNodeResourcesPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesPtrOutput) } +func (i *volumeNodeResourcesPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResources] { + return pulumix.Output[*VolumeNodeResources]{ + OutputState: i.ToVolumeNodeResourcesPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeNodeResources is a set of resource limits for scheduling of volumes. type VolumeNodeResourcesOutput struct{ *pulumi.OutputState } @@ -4251,6 +4840,12 @@ func (o VolumeNodeResourcesOutput) ToVolumeNodeResourcesPtrOutputWithContext(ctx }).(VolumeNodeResourcesPtrOutput) } +func (o VolumeNodeResourcesOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResources] { + return pulumix.Output[VolumeNodeResources]{ + OutputState: o.OutputState, + } +} + // Maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is nil, then the supported number of volumes on this node is unbounded. func (o VolumeNodeResourcesOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v VolumeNodeResources) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -4270,6 +4865,12 @@ func (o VolumeNodeResourcesPtrOutput) ToVolumeNodeResourcesPtrOutputWithContext( return o } +func (o VolumeNodeResourcesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResources] { + return pulumix.Output[*VolumeNodeResources]{ + OutputState: o.OutputState, + } +} + func (o VolumeNodeResourcesPtrOutput) Elem() VolumeNodeResourcesOutput { return o.ApplyT(func(v *VolumeNodeResources) VolumeNodeResources { if v != nil { @@ -4325,6 +4926,12 @@ func (i VolumeNodeResourcesPatchArgs) ToVolumeNodeResourcesPatchOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesPatchOutput) } +func (i VolumeNodeResourcesPatchArgs) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResourcesPatch] { + return pulumix.Output[VolumeNodeResourcesPatch]{ + OutputState: i.ToVolumeNodeResourcesPatchOutputWithContext(ctx).OutputState, + } +} + func (i VolumeNodeResourcesPatchArgs) ToVolumeNodeResourcesPatchPtrOutput() VolumeNodeResourcesPatchPtrOutput { return i.ToVolumeNodeResourcesPatchPtrOutputWithContext(context.Background()) } @@ -4366,6 +4973,12 @@ func (i *volumeNodeResourcesPatchPtrType) ToVolumeNodeResourcesPatchPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(VolumeNodeResourcesPatchPtrOutput) } +func (i *volumeNodeResourcesPatchPtrType) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResourcesPatch] { + return pulumix.Output[*VolumeNodeResourcesPatch]{ + OutputState: i.ToVolumeNodeResourcesPatchPtrOutputWithContext(ctx).OutputState, + } +} + // VolumeNodeResources is a set of resource limits for scheduling of volumes. type VolumeNodeResourcesPatchOutput struct{ *pulumi.OutputState } @@ -4391,6 +5004,12 @@ func (o VolumeNodeResourcesPatchOutput) ToVolumeNodeResourcesPatchPtrOutputWithC }).(VolumeNodeResourcesPatchPtrOutput) } +func (o VolumeNodeResourcesPatchOutput) ToOutput(ctx context.Context) pulumix.Output[VolumeNodeResourcesPatch] { + return pulumix.Output[VolumeNodeResourcesPatch]{ + OutputState: o.OutputState, + } +} + // Maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is nil, then the supported number of volumes on this node is unbounded. func (o VolumeNodeResourcesPatchOutput) Count() pulumi.IntPtrOutput { return o.ApplyT(func(v VolumeNodeResourcesPatch) *int { return v.Count }).(pulumi.IntPtrOutput) @@ -4410,6 +5029,12 @@ func (o VolumeNodeResourcesPatchPtrOutput) ToVolumeNodeResourcesPatchPtrOutputWi return o } +func (o VolumeNodeResourcesPatchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeNodeResourcesPatch] { + return pulumix.Output[*VolumeNodeResourcesPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeNodeResourcesPatchPtrOutput) Elem() VolumeNodeResourcesPatchOutput { return o.ApplyT(func(v *VolumeNodeResourcesPatch) VolumeNodeResourcesPatch { if v != nil { diff --git a/sdk/go/kubernetes/storage/v1beta1/storageClass.go b/sdk/go/kubernetes/storage/v1beta1/storageClass.go index 22421cd6b3..5330a649b9 100644 --- a/sdk/go/kubernetes/storage/v1beta1/storageClass.go +++ b/sdk/go/kubernetes/storage/v1beta1/storageClass.go @@ -12,6 +12,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. @@ -162,6 +163,12 @@ func (i *StorageClass) ToStorageClassOutputWithContext(ctx context.Context) Stor return pulumi.ToOutputWithContext(ctx, i).(StorageClassOutput) } +func (i *StorageClass) ToOutput(ctx context.Context) pulumix.Output[*StorageClass] { + return pulumix.Output[*StorageClass]{ + OutputState: i.ToStorageClassOutputWithContext(ctx).OutputState, + } +} + // StorageClassArrayInput is an input type that accepts StorageClassArray and StorageClassArrayOutput values. // You can construct a concrete instance of `StorageClassArrayInput` via: // @@ -187,6 +194,12 @@ func (i StorageClassArray) ToStorageClassArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StorageClassArrayOutput) } +func (i StorageClassArray) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClass] { + return pulumix.Output[[]*StorageClass]{ + OutputState: i.ToStorageClassArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClassMapInput is an input type that accepts StorageClassMap and StorageClassMapOutput values. // You can construct a concrete instance of `StorageClassMapInput` via: // @@ -212,6 +225,12 @@ func (i StorageClassMap) ToStorageClassMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(StorageClassMapOutput) } +func (i StorageClassMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClass] { + return pulumix.Output[map[string]*StorageClass]{ + OutputState: i.ToStorageClassMapOutputWithContext(ctx).OutputState, + } +} + type StorageClassOutput struct{ *pulumi.OutputState } func (StorageClassOutput) ElementType() reflect.Type { @@ -226,6 +245,12 @@ func (o StorageClassOutput) ToStorageClassOutputWithContext(ctx context.Context) return o } +func (o StorageClassOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageClass] { + return pulumix.Output[*StorageClass]{ + OutputState: o.OutputState, + } +} + // AllowVolumeExpansion shows whether the storage class allow volume expand func (o StorageClassOutput) AllowVolumeExpansion() pulumi.BoolOutput { return o.ApplyT(func(v *StorageClass) pulumi.BoolOutput { return v.AllowVolumeExpansion }).(pulumi.BoolOutput) @@ -290,6 +315,12 @@ func (o StorageClassArrayOutput) ToStorageClassArrayOutputWithContext(ctx contex return o } +func (o StorageClassArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClass] { + return pulumix.Output[[]*StorageClass]{ + OutputState: o.OutputState, + } +} + func (o StorageClassArrayOutput) Index(i pulumi.IntInput) StorageClassOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StorageClass { return vs[0].([]*StorageClass)[vs[1].(int)] @@ -310,6 +341,12 @@ func (o StorageClassMapOutput) ToStorageClassMapOutputWithContext(ctx context.Co return o } +func (o StorageClassMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClass] { + return pulumix.Output[map[string]*StorageClass]{ + OutputState: o.OutputState, + } +} + func (o StorageClassMapOutput) MapIndex(k pulumi.StringInput) StorageClassOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StorageClass { return vs[0].(map[string]*StorageClass)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/storageClassList.go b/sdk/go/kubernetes/storage/v1beta1/storageClassList.go index a501a2cf0e..0dd280a4cb 100644 --- a/sdk/go/kubernetes/storage/v1beta1/storageClassList.go +++ b/sdk/go/kubernetes/storage/v1beta1/storageClassList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // StorageClassList is a collection of storage classes. @@ -117,6 +118,12 @@ func (i *StorageClassList) ToStorageClassListOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StorageClassListOutput) } +func (i *StorageClassList) ToOutput(ctx context.Context) pulumix.Output[*StorageClassList] { + return pulumix.Output[*StorageClassList]{ + OutputState: i.ToStorageClassListOutputWithContext(ctx).OutputState, + } +} + // StorageClassListArrayInput is an input type that accepts StorageClassListArray and StorageClassListArrayOutput values. // You can construct a concrete instance of `StorageClassListArrayInput` via: // @@ -142,6 +149,12 @@ func (i StorageClassListArray) ToStorageClassListArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StorageClassListArrayOutput) } +func (i StorageClassListArray) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassList] { + return pulumix.Output[[]*StorageClassList]{ + OutputState: i.ToStorageClassListArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClassListMapInput is an input type that accepts StorageClassListMap and StorageClassListMapOutput values. // You can construct a concrete instance of `StorageClassListMapInput` via: // @@ -167,6 +180,12 @@ func (i StorageClassListMap) ToStorageClassListMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(StorageClassListMapOutput) } +func (i StorageClassListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassList] { + return pulumix.Output[map[string]*StorageClassList]{ + OutputState: i.ToStorageClassListMapOutputWithContext(ctx).OutputState, + } +} + type StorageClassListOutput struct{ *pulumi.OutputState } func (StorageClassListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o StorageClassListOutput) ToStorageClassListOutputWithContext(ctx context. return o } +func (o StorageClassListOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageClassList] { + return pulumix.Output[*StorageClassList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o StorageClassListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *StorageClassList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o StorageClassListArrayOutput) ToStorageClassListArrayOutputWithContext(ct return o } +func (o StorageClassListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassList] { + return pulumix.Output[[]*StorageClassList]{ + OutputState: o.OutputState, + } +} + func (o StorageClassListArrayOutput) Index(i pulumi.IntInput) StorageClassListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StorageClassList { return vs[0].([]*StorageClassList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o StorageClassListMapOutput) ToStorageClassListMapOutputWithContext(ctx co return o } +func (o StorageClassListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassList] { + return pulumix.Output[map[string]*StorageClassList]{ + OutputState: o.OutputState, + } +} + func (o StorageClassListMapOutput) MapIndex(k pulumi.StringInput) StorageClassListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StorageClassList { return vs[0].(map[string]*StorageClassList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/storageClassPatch.go b/sdk/go/kubernetes/storage/v1beta1/storageClassPatch.go index 1ca126ac0a..34758114b1 100644 --- a/sdk/go/kubernetes/storage/v1beta1/storageClassPatch.go +++ b/sdk/go/kubernetes/storage/v1beta1/storageClassPatch.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -164,6 +165,12 @@ func (i *StorageClassPatch) ToStorageClassPatchOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchOutput) } +func (i *StorageClassPatch) ToOutput(ctx context.Context) pulumix.Output[*StorageClassPatch] { + return pulumix.Output[*StorageClassPatch]{ + OutputState: i.ToStorageClassPatchOutputWithContext(ctx).OutputState, + } +} + // StorageClassPatchArrayInput is an input type that accepts StorageClassPatchArray and StorageClassPatchArrayOutput values. // You can construct a concrete instance of `StorageClassPatchArrayInput` via: // @@ -189,6 +196,12 @@ func (i StorageClassPatchArray) ToStorageClassPatchArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchArrayOutput) } +func (i StorageClassPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassPatch] { + return pulumix.Output[[]*StorageClassPatch]{ + OutputState: i.ToStorageClassPatchArrayOutputWithContext(ctx).OutputState, + } +} + // StorageClassPatchMapInput is an input type that accepts StorageClassPatchMap and StorageClassPatchMapOutput values. // You can construct a concrete instance of `StorageClassPatchMapInput` via: // @@ -214,6 +227,12 @@ func (i StorageClassPatchMap) ToStorageClassPatchMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StorageClassPatchMapOutput) } +func (i StorageClassPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassPatch] { + return pulumix.Output[map[string]*StorageClassPatch]{ + OutputState: i.ToStorageClassPatchMapOutputWithContext(ctx).OutputState, + } +} + type StorageClassPatchOutput struct{ *pulumi.OutputState } func (StorageClassPatchOutput) ElementType() reflect.Type { @@ -228,6 +247,12 @@ func (o StorageClassPatchOutput) ToStorageClassPatchOutputWithContext(ctx contex return o } +func (o StorageClassPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*StorageClassPatch] { + return pulumix.Output[*StorageClassPatch]{ + OutputState: o.OutputState, + } +} + // AllowVolumeExpansion shows whether the storage class allow volume expand func (o StorageClassPatchOutput) AllowVolumeExpansion() pulumi.BoolPtrOutput { return o.ApplyT(func(v *StorageClassPatch) pulumi.BoolPtrOutput { return v.AllowVolumeExpansion }).(pulumi.BoolPtrOutput) @@ -292,6 +317,12 @@ func (o StorageClassPatchArrayOutput) ToStorageClassPatchArrayOutputWithContext( return o } +func (o StorageClassPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StorageClassPatch] { + return pulumix.Output[[]*StorageClassPatch]{ + OutputState: o.OutputState, + } +} + func (o StorageClassPatchArrayOutput) Index(i pulumi.IntInput) StorageClassPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StorageClassPatch { return vs[0].([]*StorageClassPatch)[vs[1].(int)] @@ -312,6 +343,12 @@ func (o StorageClassPatchMapOutput) ToStorageClassPatchMapOutputWithContext(ctx return o } +func (o StorageClassPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StorageClassPatch] { + return pulumix.Output[map[string]*StorageClassPatch]{ + OutputState: o.OutputState, + } +} + func (o StorageClassPatchMapOutput) MapIndex(k pulumi.StringInput) StorageClassPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StorageClassPatch { return vs[0].(map[string]*StorageClassPatch)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/volumeAttachment.go b/sdk/go/kubernetes/storage/v1beta1/volumeAttachment.go index 27514bea4c..3d0a056998 100644 --- a/sdk/go/kubernetes/storage/v1beta1/volumeAttachment.go +++ b/sdk/go/kubernetes/storage/v1beta1/volumeAttachment.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. @@ -130,6 +131,12 @@ func (i *VolumeAttachment) ToVolumeAttachmentOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentOutput) } +func (i *VolumeAttachment) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachment] { + return pulumix.Output[*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentArrayInput is an input type that accepts VolumeAttachmentArray and VolumeAttachmentArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentArrayInput` via: // @@ -155,6 +162,12 @@ func (i VolumeAttachmentArray) ToVolumeAttachmentArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentArrayOutput) } +func (i VolumeAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachment] { + return pulumix.Output[[]*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentMapInput is an input type that accepts VolumeAttachmentMap and VolumeAttachmentMapOutput values. // You can construct a concrete instance of `VolumeAttachmentMapInput` via: // @@ -180,6 +193,12 @@ func (i VolumeAttachmentMap) ToVolumeAttachmentMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentMapOutput) } +func (i VolumeAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachment] { + return pulumix.Output[map[string]*VolumeAttachment]{ + OutputState: i.ToVolumeAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentOutput struct{ *pulumi.OutputState } func (VolumeAttachmentOutput) ElementType() reflect.Type { @@ -194,6 +213,12 @@ func (o VolumeAttachmentOutput) ToVolumeAttachmentOutputWithContext(ctx context. return o } +func (o VolumeAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachment] { + return pulumix.Output[*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *VolumeAttachment) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -233,6 +258,12 @@ func (o VolumeAttachmentArrayOutput) ToVolumeAttachmentArrayOutputWithContext(ct return o } +func (o VolumeAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachment] { + return pulumix.Output[[]*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachment { return vs[0].([]*VolumeAttachment)[vs[1].(int)] @@ -253,6 +284,12 @@ func (o VolumeAttachmentMapOutput) ToVolumeAttachmentMapOutputWithContext(ctx co return o } +func (o VolumeAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachment] { + return pulumix.Output[map[string]*VolumeAttachment]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachment { return vs[0].(map[string]*VolumeAttachment)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentList.go b/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentList.go index 1b8b1d49b8..9bfd2023be 100644 --- a/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentList.go +++ b/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentList.go @@ -11,6 +11,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // VolumeAttachmentList is a collection of VolumeAttachment objects. @@ -117,6 +118,12 @@ func (i *VolumeAttachmentList) ToVolumeAttachmentListOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListOutput) } +func (i *VolumeAttachmentList) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentList] { + return pulumix.Output[*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentListArrayInput is an input type that accepts VolumeAttachmentListArray and VolumeAttachmentListArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentListArrayInput` via: // @@ -142,6 +149,12 @@ func (i VolumeAttachmentListArray) ToVolumeAttachmentListArrayOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListArrayOutput) } +func (i VolumeAttachmentListArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentList] { + return pulumix.Output[[]*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentListMapInput is an input type that accepts VolumeAttachmentListMap and VolumeAttachmentListMapOutput values. // You can construct a concrete instance of `VolumeAttachmentListMapInput` via: // @@ -167,6 +180,12 @@ func (i VolumeAttachmentListMap) ToVolumeAttachmentListMapOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentListMapOutput) } +func (i VolumeAttachmentListMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentList] { + return pulumix.Output[map[string]*VolumeAttachmentList]{ + OutputState: i.ToVolumeAttachmentListMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentListOutput struct{ *pulumi.OutputState } func (VolumeAttachmentListOutput) ElementType() reflect.Type { @@ -181,6 +200,12 @@ func (o VolumeAttachmentListOutput) ToVolumeAttachmentListOutputWithContext(ctx return o } +func (o VolumeAttachmentListOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentList] { + return pulumix.Output[*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentListOutput) ApiVersion() pulumi.StringOutput { return o.ApplyT(func(v *VolumeAttachmentList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) @@ -215,6 +240,12 @@ func (o VolumeAttachmentListArrayOutput) ToVolumeAttachmentListArrayOutputWithCo return o } +func (o VolumeAttachmentListArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentList] { + return pulumix.Output[[]*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentListArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentListOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachmentList { return vs[0].([]*VolumeAttachmentList)[vs[1].(int)] @@ -235,6 +266,12 @@ func (o VolumeAttachmentListMapOutput) ToVolumeAttachmentListMapOutputWithContex return o } +func (o VolumeAttachmentListMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentList] { + return pulumix.Output[map[string]*VolumeAttachmentList]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentListMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentListOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachmentList { return vs[0].(map[string]*VolumeAttachmentList)[vs[1].(string)] diff --git a/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentPatch.go b/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentPatch.go index 1d6e19cf44..076971175d 100644 --- a/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentPatch.go +++ b/sdk/go/kubernetes/storage/v1beta1/volumeAttachmentPatch.go @@ -10,6 +10,7 @@ import ( "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/internal" metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" ) // Patch resources are used to modify existing Kubernetes resources by using @@ -132,6 +133,12 @@ func (i *VolumeAttachmentPatch) ToVolumeAttachmentPatchOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchOutput) } +func (i *VolumeAttachmentPatch) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentPatch] { + return pulumix.Output[*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentPatchArrayInput is an input type that accepts VolumeAttachmentPatchArray and VolumeAttachmentPatchArrayOutput values. // You can construct a concrete instance of `VolumeAttachmentPatchArrayInput` via: // @@ -157,6 +164,12 @@ func (i VolumeAttachmentPatchArray) ToVolumeAttachmentPatchArrayOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchArrayOutput) } +func (i VolumeAttachmentPatchArray) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentPatch] { + return pulumix.Output[[]*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchArrayOutputWithContext(ctx).OutputState, + } +} + // VolumeAttachmentPatchMapInput is an input type that accepts VolumeAttachmentPatchMap and VolumeAttachmentPatchMapOutput values. // You can construct a concrete instance of `VolumeAttachmentPatchMapInput` via: // @@ -182,6 +195,12 @@ func (i VolumeAttachmentPatchMap) ToVolumeAttachmentPatchMapOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(VolumeAttachmentPatchMapOutput) } +func (i VolumeAttachmentPatchMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentPatch] { + return pulumix.Output[map[string]*VolumeAttachmentPatch]{ + OutputState: i.ToVolumeAttachmentPatchMapOutputWithContext(ctx).OutputState, + } +} + type VolumeAttachmentPatchOutput struct{ *pulumi.OutputState } func (VolumeAttachmentPatchOutput) ElementType() reflect.Type { @@ -196,6 +215,12 @@ func (o VolumeAttachmentPatchOutput) ToVolumeAttachmentPatchOutputWithContext(ct return o } +func (o VolumeAttachmentPatchOutput) ToOutput(ctx context.Context) pulumix.Output[*VolumeAttachmentPatch] { + return pulumix.Output[*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + // APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources func (o VolumeAttachmentPatchOutput) ApiVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *VolumeAttachmentPatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) @@ -235,6 +260,12 @@ func (o VolumeAttachmentPatchArrayOutput) ToVolumeAttachmentPatchArrayOutputWith return o } +func (o VolumeAttachmentPatchArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VolumeAttachmentPatch] { + return pulumix.Output[[]*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentPatchArrayOutput) Index(i pulumi.IntInput) VolumeAttachmentPatchOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeAttachmentPatch { return vs[0].([]*VolumeAttachmentPatch)[vs[1].(int)] @@ -255,6 +286,12 @@ func (o VolumeAttachmentPatchMapOutput) ToVolumeAttachmentPatchMapOutputWithCont return o } +func (o VolumeAttachmentPatchMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VolumeAttachmentPatch] { + return pulumix.Output[map[string]*VolumeAttachmentPatch]{ + OutputState: o.OutputState, + } +} + func (o VolumeAttachmentPatchMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachmentPatchOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeAttachmentPatch { return vs[0].(map[string]*VolumeAttachmentPatch)[vs[1].(string)] diff --git a/sdk/nodejs/package.json b/sdk/nodejs/package.json index 2d15ffa4e7..7ed8b4a8eb 100644 --- a/sdk/nodejs/package.json +++ b/sdk/nodejs/package.json @@ -11,8 +11,7 @@ "repository": "https://github.com/pulumi/pulumi-kubernetes", "license": "Apache-2.0", "scripts": { - "build": "tsc", - "install": "node scripts/install-pulumi-plugin.js resource kubernetes ${VERSION}" + "build": "tsc" }, "dependencies": { "@pulumi/pulumi": "^3.25.0",