2019-07-30 10:25:00 +03:00
|
|
|
{ MutatingWebhookConfiguration =
|
|
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.MutatingWebhookConfiguration.dhall sha256:f27ab85998c7882ffab74d8ba730589f53723080428e4e920e6efade51db4f0d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, MutatingWebhookConfigurationList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.MutatingWebhookConfigurationList.dhall sha256:f4237911d47c10d12ac2e78897c91ca1b35f199300a95f61eb91b24794a4642a
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RuleWithOperations =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.RuleWithOperations.dhall sha256:1bbba1effc10003614574e80ca8c637a74f00742fba42233b7a6da4a65c8a628
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ValidatingWebhookConfiguration =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.ValidatingWebhookConfiguration.dhall sha256:9670a38d56f1b23d9065a8e2a084f745b2f3e740b77fcd0890ff571638af82ae
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ValidatingWebhookConfigurationList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.ValidatingWebhookConfigurationList.dhall sha256:4f7002727eeab9eb17968657a6e89034cf8209ebe4d22fbe91a54544e6349f5c
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, Webhook =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.Webhook.dhall sha256:7214fd061ac63eb9ce2c200b3dd63f57c526e1b81028ab1b28b785543b5b4ea3
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, WebhookClientConfig =
|
|
|
|
|
./defaults/io.k8s.api.admissionregistration.v1beta1.WebhookClientConfig.dhall sha256:a7b85eb33951f7567da092ac5baf314dad2ccd2b4989d44f64bf5adb796c9e0c
|
|
|
|
|
, ControllerRevision =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.ControllerRevision.dhall sha256:87f7d5b8e8ab9b5ce5ff3acd2b9019768805ca7637bc49b78d158faeb238b53a
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ControllerRevisionList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.ControllerRevisionList.dhall sha256:2b1febe65e3c7312fa68638ae497c9f5175dfad9bc8d824379e5994dbcebbae4
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DaemonSet =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.DaemonSet.dhall sha256:fbf1018ef8cf3df9e728d16c76d37a94317965563cd57505b67e782e478c2778
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DaemonSetCondition =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.DaemonSetCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, DaemonSetList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.DaemonSetList.dhall sha256:7e430b62b21cb48a188972c3b8dc7102e36679ff2495df6e3eb51f9aa5e67282
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DaemonSetSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.DaemonSetSpec.dhall sha256:11092f06ddc345d37b47f3579d878240fb5f4dd6038d500afc7c4a95dff3a104
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DaemonSetStatus =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.DaemonSetStatus.dhall sha256:5587c887561bdd5d183223f7f385fa666926e224b941a64b382d7ad8cbdc834c
|
|
|
|
|
, DaemonSetUpdateStrategy =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.DaemonSetUpdateStrategy.dhall sha256:6de1f868344d8b18c50055d21a0c0c7f264251e2e581ba6d40343eab04c62483
|
|
|
|
|
, Deployment =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.Deployment.dhall sha256:2340ba9f1919ec76acdbe7fedda110cac4d5e70512f25124e1afea47e64a4e2e
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DeploymentCondition =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.DeploymentCondition.dhall sha256:006ebe956ae6e2918eb18beed3f6378d0f79437bfc449f4b6c7852206a7c7e5d
|
|
|
|
|
, DeploymentList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.DeploymentList.dhall sha256:6965df15e542b2bd210a894b27123353092eaaf3a7f9e247ac7a1a5bbfa6dc1a
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DeploymentSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.DeploymentSpec.dhall sha256:27ded6553fb022a96008d7f91968f527f286c89fa9e82b05d6f2a12319f06afc
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, DeploymentStatus =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.DeploymentStatus.dhall sha256:30679d54ce5f916687650eb7fce39a50af3307d55b6c0f8a5ece4855f57614c4
|
|
|
|
|
, DeploymentStrategy =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.DeploymentStrategy.dhall sha256:b1ac4e6f9f75f2e3af37535360896f91c9c944dded5a95dd3621a4e64462ffb8
|
|
|
|
|
, ReplicaSet =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.ReplicaSet.dhall sha256:20ffc299a4570e7bf0e8b3ccea876648b23fa0a4af60dca4f9f4bc2c615df90e
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ReplicaSetCondition =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.ReplicaSetCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, ReplicaSetList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.ReplicaSetList.dhall sha256:90c938e2106a5fb061f600c49ecf4753d0200722bcb6905e1c9774131c3c067c
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ReplicaSetSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.ReplicaSetSpec.dhall sha256:25e2602f037a0dfce66d1ca0e17536dbe3a867967beaed3c6cc805b5d6bd881a
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ReplicaSetStatus =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.ReplicaSetStatus.dhall sha256:fdf1330beaa8b581ba9a9bdd3976ef99bbf983e17a7a380462acf031f15afe10
|
|
|
|
|
, RollingUpdateDaemonSet =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.RollingUpdateDaemonSet.dhall sha256:58f66799ef9f167835e8533e53a2685ab07e3f04dd173e8bc1381fe886da2c29
|
|
|
|
|
, RollingUpdateDeployment =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.RollingUpdateDeployment.dhall sha256:c80435678f5f7940a4e2004154b3fe7ca0d0af31c691c9c184dd4bad82ce5d11
|
|
|
|
|
, RollingUpdateStatefulSetStrategy =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy.dhall sha256:4d9feb8034f9f58692aebeed06474c07c387e5b8bc11c40dc36ec6390a26fa63
|
|
|
|
|
, StatefulSet =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.StatefulSet.dhall sha256:90cde3f057f09a4561a0d0f089cf8c536e9f2a674aa568afc9d62aba0d9a2e48
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, StatefulSetCondition =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.StatefulSetCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, StatefulSetList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.StatefulSetList.dhall sha256:9c2be7df21188b9dc58b66a1a1f881f891708edb85a4cce4a25fe9080a287056
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, StatefulSetSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.apps.v1.StatefulSetSpec.dhall sha256:f57eacd092770dd294e1c90b9b3737c6c41b7a9aacf39ebb671ffde58d0570cb
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, StatefulSetStatus =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.StatefulSetStatus.dhall sha256:c546b1ef00fc415c624e2122e201c340aa5cb2e3fabcfc7076b9dd61be0b71f0
|
|
|
|
|
, StatefulSetUpdateStrategy =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1.StatefulSetUpdateStrategy.dhall sha256:5b3f71bcd6db3b8a75e2b9308d5c10c4c1020b8f8e4d17219fc0ca0f67f68a67
|
|
|
|
|
, DeploymentRollback =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1beta1.DeploymentRollback.dhall sha256:d2720fefc4ffc1569e9d49f060eead95e98a667d7495e4a3058840f2902858cf
|
|
|
|
|
, RollbackConfig =
|
|
|
|
|
./defaults/io.k8s.api.apps.v1beta1.RollbackConfig.dhall sha256:259e5eb90283b13866747437813b461e5a93a794577b1435628502e2b6be32e2
|
|
|
|
|
, AuditSink =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.auditregistration.v1alpha1.AuditSink.dhall sha256:bfc4a3de2dd60086dd588eb354fd82a4bf7a9407f338d306b88b6be90ae72897
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, AuditSinkList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.auditregistration.v1alpha1.AuditSinkList.dhall sha256:8e147fa4e2d3a8514bce4cd35681daeaad354c856bf8612d20cf4d1ab97231f0
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, AuditSinkSpec =
|
|
|
|
|
./defaults/io.k8s.api.auditregistration.v1alpha1.AuditSinkSpec.dhall sha256:e00c200a26950c014d794852e9d4a047b959d05bdd6544689f60f7495509d377
|
|
|
|
|
, Policy =
|
|
|
|
|
./defaults/io.k8s.api.auditregistration.v1alpha1.Policy.dhall sha256:ebf08f309bcdccd7e3b29b066db37deb2179379f2e0da6b9309fc2bd26a29146
|
|
|
|
|
, WebhookThrottleConfig =
|
|
|
|
|
./defaults/io.k8s.api.auditregistration.v1alpha1.WebhookThrottleConfig.dhall sha256:d0dfbe49d65fe19b9d65183205f8450295ef3c09329069e2c2139b8985fb7345
|
|
|
|
|
, TokenReview =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.authentication.v1.TokenReview.dhall sha256:619528d9b91ebc0f9772ab7af2a422920b8aebe8a75271b1a9deaa9a7d36a437
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, TokenReviewSpec =
|
|
|
|
|
./defaults/io.k8s.api.authentication.v1.TokenReviewSpec.dhall sha256:65f2fa7d9a1cceb6d3ee0a8f8fb233dd0726a1044d1ef3a8cf7d77d4346ead45
|
|
|
|
|
, TokenReviewStatus =
|
|
|
|
|
./defaults/io.k8s.api.authentication.v1.TokenReviewStatus.dhall sha256:b6faffbeaee63e727fb67fe28da5655cb20974b43c165a938d3828eb706322e6
|
|
|
|
|
, UserInfo =
|
|
|
|
|
./defaults/io.k8s.api.authentication.v1.UserInfo.dhall sha256:cdab95ad0fd07ecc2d13abfe7df52adea86e4f3b408a75b52dedf49190b8ebc1
|
|
|
|
|
, LocalSubjectAccessReview =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.authorization.v1.LocalSubjectAccessReview.dhall sha256:aab5aa2d1772d2f4da4beaea67ccaba1b259b7630d0fc1e4d42bb2e3f0727cfa
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NonResourceAttributes =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.NonResourceAttributes.dhall sha256:f12af301fdbd5e90c588eb5e190ba48e9390b3f5eb43af39dc578cd6fd1293fc
|
|
|
|
|
, NonResourceRule =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.NonResourceRule.dhall sha256:705c206ac6be862481a4ddb6a422f926eabc0f5e0e987e20abb2908c581f541d
|
|
|
|
|
, ResourceAttributes =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.ResourceAttributes.dhall sha256:e6943bc921d303c429607a63e493b22f938cde64bafcfbd2faf4867f18935dcb
|
|
|
|
|
, ResourceRule =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.ResourceRule.dhall sha256:e040ec747232e08f413d8411f60f458eb68e388b29e4ba0e92d336cb2fc04bca
|
|
|
|
|
, SelfSubjectAccessReview =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.authorization.v1.SelfSubjectAccessReview.dhall sha256:66b716155c354fcc5eec4ce8b224e2a92d8db814fd5c1d7f2beba69aa8cd6a44
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, SelfSubjectAccessReviewSpec =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.SelfSubjectAccessReviewSpec.dhall sha256:6b2dd0d736292f0840bc7a5629636ed13bc46d59e26c05352dc67b94d00d5987
|
|
|
|
|
, SelfSubjectRulesReview =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.authorization.v1.SelfSubjectRulesReview.dhall sha256:61df42aaa0db943a724b07dc14d5ea7f2a43330f825009dca5c02de30e3a344a
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, SelfSubjectRulesReviewSpec =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.SelfSubjectRulesReviewSpec.dhall sha256:ffe97f63e5bc2a49da3738cfabf980f1cfed5d0df38c2d9c37f7e7b43caddf9e
|
|
|
|
|
, SubjectAccessReview =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.authorization.v1.SubjectAccessReview.dhall sha256:38fd069bbb7d3bb64f08c39e72ba12bd11c77a4227bf00026ff0e5425bec2053
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, SubjectAccessReviewSpec =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.SubjectAccessReviewSpec.dhall sha256:c1b2206c8b75d007995497b7c03e9e0f5f5e6e5ac14d22f6adca786f1855cd52
|
|
|
|
|
, SubjectAccessReviewStatus =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.SubjectAccessReviewStatus.dhall sha256:fcd839dac5487cfbcbfbe8eca4922bf484f7e6e46a6f88598e78bbe558bc3b9a
|
|
|
|
|
, SubjectRulesReviewStatus =
|
|
|
|
|
./defaults/io.k8s.api.authorization.v1.SubjectRulesReviewStatus.dhall sha256:85e4fa1752fd9b86c8195b4fcefeea7a9d36e61c22db395f59fc9097162444f0
|
|
|
|
|
, Scale =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.autoscaling.v1.Scale.dhall sha256:4ee06d830d729418f9cb04a7e46bae24ead9791dc144afc4add8d8ca4ce1849b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ScaleSpec =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v1.ScaleSpec.dhall sha256:62ed60d23f95d26219c64410857bba02b39e118e8ac106528eceb8ae1d8c93e3
|
|
|
|
|
, ScaleStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v1.ScaleStatus.dhall sha256:378366369e27427f71184050ac6666edc8c423954510952d39248ebce88acc42
|
|
|
|
|
, CrossVersionObjectReference =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, ExternalMetricSource =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.ExternalMetricSource.dhall sha256:48114ac50415ff4d051a4e57423a2f4e7b12398749825f5625697c3d2c8897ca
|
|
|
|
|
, ExternalMetricStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus.dhall sha256:02e4e6fed3ab9c115a0907b2968148d606dc653c55817df20d3fc0261d4ebf5e
|
|
|
|
|
, HorizontalPodAutoscaler =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler.dhall sha256:8623db6c54a3051d7055fe67197621a618c2f1c9f50f75516515af361e655a07
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, HorizontalPodAutoscalerCondition =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, HorizontalPodAutoscalerList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerList.dhall sha256:ea385b418bc1d4d68c631850f6414eb92c4c4e830237170b7edfa922a7edff7b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, HorizontalPodAutoscalerSpec =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec.dhall sha256:fe6875b9e4725712d446702070da05d0bfc35fd735c2ec49f9320c35afabe5af
|
|
|
|
|
, HorizontalPodAutoscalerStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus.dhall sha256:cbff68bb1ea938da5f918d0e5680339980ba8376abece6f1953dd3bde2ecadea
|
|
|
|
|
, MetricIdentifier =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.MetricIdentifier.dhall sha256:24b233185318f27e20efb775ea6e180fe9f85b972467cb291cf3721a13ce3d67
|
|
|
|
|
, MetricSpec =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.MetricSpec.dhall sha256:eb13e7188c886c5d457a7aa43a2ebf28a04a04e5e69ace4d880974bc81bdfc35
|
|
|
|
|
, MetricStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.MetricStatus.dhall sha256:ea966e725f7d3720f9b6efbbde14648ba17bf75ba29af394d5d4824e5fbb4a3c
|
|
|
|
|
, MetricTarget =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.MetricTarget.dhall sha256:5a8d96e3b4724d60808b6e21a8a4d7a2e59303fe762edfddc10a79588da3e922
|
|
|
|
|
, MetricValueStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.MetricValueStatus.dhall sha256:5a8d96e3b4724d60808b6e21a8a4d7a2e59303fe762edfddc10a79588da3e922
|
|
|
|
|
, ObjectMetricSource =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.ObjectMetricSource.dhall sha256:b39459c4df962d15774b6da5195c2d60a63b1e086dff578f5c878d548ce710a1
|
|
|
|
|
, ObjectMetricStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus.dhall sha256:76ead5ef5e7344a6e7f1d5edb2eeab15485d4f76c1008dd22326d364d105e13d
|
|
|
|
|
, PodsMetricSource =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.PodsMetricSource.dhall sha256:48114ac50415ff4d051a4e57423a2f4e7b12398749825f5625697c3d2c8897ca
|
|
|
|
|
, PodsMetricStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.PodsMetricStatus.dhall sha256:02e4e6fed3ab9c115a0907b2968148d606dc653c55817df20d3fc0261d4ebf5e
|
|
|
|
|
, ResourceMetricSource =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.ResourceMetricSource.dhall sha256:6acbd8e96c616377b26f34aee5642f362ec923edbb4135b27edec8051781eae7
|
|
|
|
|
, ResourceMetricStatus =
|
|
|
|
|
./defaults/io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus.dhall sha256:fbfa7530da79f247d627bb9afe6e68bcaab40b3477d8227611e91610d45ec136
|
|
|
|
|
, Job =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1.Job.dhall sha256:52ba265441e2d10e6929de1d726cf0f8df6248e5d88eecdae4a83888115efdd8
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, JobCondition =
|
|
|
|
|
./defaults/io.k8s.api.batch.v1.JobCondition.dhall sha256:d7a55966e74169d85d6a02388fd65f2759da9f8005cc0be8bee6bed7398af0eb
|
|
|
|
|
, JobList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1.JobList.dhall sha256:ab6ce75229349b31cd95988e55e1f769c996728b6ee9235d837e1896537af8b5
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, JobSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1.JobSpec.dhall sha256:1ce6d95b0268bb745f8c964b8a79d88c40b9e1d4d6e4568537d9b01a0f1e6d5b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, JobStatus =
|
|
|
|
|
./defaults/io.k8s.api.batch.v1.JobStatus.dhall sha256:a8d8e591e2fe1686c47015ccb1ec4d526b2556e393d2971d9df4f2d670c66f1e
|
|
|
|
|
, CronJob =
|
2019-11-17 05:18:44 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1beta1.CronJob.dhall sha256:392527fc2b80465f7fcc5ab9b4180c1541b0fceb58e584b65f67b7b7a3a70c3a
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CronJobList =
|
2019-11-17 05:18:44 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1beta1.CronJobList.dhall sha256:72a6a8157f567f5a60b8b34eea8b11e6199ddbeaefa7fcac5a645fa61257f645
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CronJobSpec =
|
2019-11-17 05:18:44 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1beta1.CronJobSpec.dhall sha256:31b776fcebe0d3da14c9af5c5e96a35fe3b73883717a1cd26234f48064950325
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CronJobStatus =
|
2019-11-17 05:18:44 +03:00
|
|
|
./defaults/io.k8s.api.batch.v1beta1.CronJobStatus.dhall sha256:74d9ee0419f4a414496b1195a1fa782696a07d131edf8194fa2d3dae5253a70b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, JobTemplateSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.batch.v2alpha1.JobTemplateSpec.dhall sha256:2064710fdd9153299b2090c2c3a3c828153d5b94c346da0c252ebad5f18bf9d6
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CertificateSigningRequest =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.certificates.v1beta1.CertificateSigningRequest.dhall sha256:2fea6b96a80fb5224d9c369c313b34e70e73c8ff8026a6f788ac1a0c26314ed2
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CertificateSigningRequestCondition =
|
|
|
|
|
./defaults/io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition.dhall sha256:4b5ddb10b6f114f42e40543b90c3eba323786f0cbf5d2bd5bab81bfefa7766e4
|
|
|
|
|
, CertificateSigningRequestList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.certificates.v1beta1.CertificateSigningRequestList.dhall sha256:7e37348d742723c7ae1529764ae903836a72e09187d7a7b577d193e50b8b5480
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CertificateSigningRequestSpec =
|
|
|
|
|
./defaults/io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec.dhall sha256:f090c44814262ebd47ac454b221f2498d0b166c07fd28bdb9b5d1f4fc7fc4b61
|
|
|
|
|
, CertificateSigningRequestStatus =
|
|
|
|
|
./defaults/io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus.dhall sha256:eca5b67fa3166f8aa453ec6c25ea93c0c747c6012c4c12ebbea6356f59713c36
|
|
|
|
|
, Lease =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.coordination.v1.Lease.dhall sha256:b0918971ccc7b439d7e0bcc60128b6db3feb5a926fda6015dc225869e087249d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, LeaseList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.coordination.v1.LeaseList.dhall sha256:eadc707c8179113260bb8c36ecbf1d9ed8f97aa86856a173c89588b6c04834b0
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, LeaseSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.coordination.v1.LeaseSpec.dhall sha256:0f70f751b4b828ecdbc04a4147bada6bde6c27a7d7fad1281f8d2b5a323ca35f
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, AWSElasticBlockStoreVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource.dhall sha256:615e35b270fce43209e478f061aa33a4511051080566a27fdabd5f27805d547d
|
|
|
|
|
, Affinity =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Affinity.dhall sha256:9a8a38df61944f429d69c9f820e4cab47373577a0802daa092e1ea092fa2fa26
|
|
|
|
|
, AttachedVolume =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.AttachedVolume.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, AzureDiskVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.AzureDiskVolumeSource.dhall sha256:c3ecd741e21931695d622a376d3e624b79d1333b6e5b8c41a336a87af70bfa6f
|
|
|
|
|
, AzureFilePersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.AzureFilePersistentVolumeSource.dhall sha256:249e3da93093626c4eff7f3edf5b6ffa4d226947483c362cc840823185a85c84
|
|
|
|
|
, AzureFileVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.AzureFileVolumeSource.dhall sha256:3f3b6353d4261e707e747ca39d47871803e8006597c4d50b46c8bc39f0c4f538
|
|
|
|
|
, Binding =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Binding.dhall sha256:d0ba38af6eafab0ec7245d3a4a8267f53c04c2b3f79f75b56b9e48967391cf21
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CSIPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.CSIPersistentVolumeSource.dhall sha256:27e4e2b5f7e039428c707ffcd6a186aade2c1e5777b83df38b952bbf4b164890
|
2019-07-30 10:25:00 +03:00
|
|
|
, CSIVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.CSIVolumeSource.dhall sha256:0dcb1a01ded4b8f0e82a1be520a5891ce16539f570efd5854bd6107beaddf2e3
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, Capabilities =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Capabilities.dhall sha256:0ba24051bbc1766e21e9edb391fe4fc3adc79d0ede227dd6500d51267d0790a9
|
|
|
|
|
, CephFSPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.CephFSPersistentVolumeSource.dhall sha256:53743424014963675272d2a66f0cf6ce87ece3dbe942cd4738544f8d28eeafe3
|
|
|
|
|
, CephFSVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.CephFSVolumeSource.dhall sha256:b2a2944d70752d48608fd64b1ded0b463b874d93c0cc5988df6ad2bdc42d8ff6
|
|
|
|
|
, CinderPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.CinderPersistentVolumeSource.dhall sha256:a3f455d6224c9484caaa34b01588e88c27c77a517eefa5e273d71dda28f53d71
|
|
|
|
|
, CinderVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.CinderVolumeSource.dhall sha256:8e06505c7e36ff11a24db1780ac61294be042ada053f701e54e8149cf21a13e1
|
|
|
|
|
, ClientIPConfig =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ClientIPConfig.dhall sha256:d09afe2b02a55f0e2b4148d749dabfd10cd9ca28b69fb3a80eeac87162e8ea33
|
|
|
|
|
, ComponentCondition =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ComponentCondition.dhall sha256:2a87848e3871f0d52e6fe65856823af6d2a15568b2315043a8ad3cd716984a67
|
|
|
|
|
, ComponentStatus =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ComponentStatus.dhall sha256:31094bc631b6e1f83bcf1636b820fa98ff2c680a0e5476c31ccf1a043238fd24
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ComponentStatusList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ComponentStatusList.dhall sha256:f0028c0bcaa6ecd147fd8d385ef16a386aa2c2189be7385483848d6798971284
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ConfigMap =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMap.dhall sha256:e26178b4b41a972532be4372cc5db83eb1e3287bb978d9c32e9404b81cce9b31
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ConfigMapEnvSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMapEnvSource.dhall sha256:f48fba5eae86d740341445e19fa71fbf9cfe45d2aff60071682bc95ea7877387
|
|
|
|
|
, ConfigMapKeySelector =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMapKeySelector.dhall sha256:f48fba5eae86d740341445e19fa71fbf9cfe45d2aff60071682bc95ea7877387
|
|
|
|
|
, ConfigMapList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMapList.dhall sha256:ab4e7496a251654478e0587864d6c02867848ed17596344c6c0927c740c05c6b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ConfigMapNodeConfigSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMapNodeConfigSource.dhall sha256:3d113c81519001211e7181315ce43d0cea7e2edd45757b14ac3fbe2b0927f605
|
|
|
|
|
, ConfigMapProjection =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMapProjection.dhall sha256:7e48f7ea13020516ee9d29255b98f44501fc93dc8982cd23e52e19220ac3d370
|
|
|
|
|
, ConfigMapVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ConfigMapVolumeSource.dhall sha256:2bb201ade4ea88d081540599ca8a0a4a7896bf6fdcb4b2efbd387b087876ea8b
|
|
|
|
|
, Container =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Container.dhall sha256:53ba7a6d6ceff0c0bd4b51be39efd8c829bfd8a6736500f9bba461848416344e
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ContainerImage =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerImage.dhall sha256:00c38242e0d4bf075703d2d9785b06387d461d4dfe65bdd97442d49c9cbb8c8e
|
|
|
|
|
, ContainerPort =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerPort.dhall sha256:c033cb6b3a0c181d2c7a26d7e1b13d3144552ea9a7bf58d8f03fd1671394d6cc
|
|
|
|
|
, ContainerState =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerState.dhall sha256:e94dfcd94bd6ff4f5300ef04194db100c96a5a12d03ff7d43cb584a0db167e01
|
|
|
|
|
, ContainerStateRunning =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerStateRunning.dhall sha256:52bf96358788dca2898fb472254f194bc0bdef83c427c592686b7c3031cf3945
|
|
|
|
|
, ContainerStateTerminated =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerStateTerminated.dhall sha256:9edeb5caab08a944a558c204042c3c64805f4850cb20d7e7b00667a2cbf8a596
|
|
|
|
|
, ContainerStateWaiting =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerStateWaiting.dhall sha256:c6a5b413c2306dd65fa170894b76d6c897ea5132d84f255886df93df57d290ee
|
|
|
|
|
, ContainerStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ContainerStatus.dhall sha256:221c4d2737d6d65d1368441e34c401853126d91738710370b806799709232087
|
|
|
|
|
, DaemonEndpoint =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.DaemonEndpoint.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, DownwardAPIProjection =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.DownwardAPIProjection.dhall sha256:bd8951de61aa9ac374341ccae678bbbc6c725b1d321fbe924ef285803779df87
|
|
|
|
|
, DownwardAPIVolumeFile =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.DownwardAPIVolumeFile.dhall sha256:15542940c502e0c3d397df3e1a4cd0da09d992081d72cb22e907c8f933810442
|
|
|
|
|
, DownwardAPIVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.DownwardAPIVolumeSource.dhall sha256:03326853af6331c85833277c17423f687abf240247278f9ba3c385ea24f93849
|
|
|
|
|
, EmptyDirVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EmptyDirVolumeSource.dhall sha256:4ac638bf8e394cb0d1e8826f6c001c8e5a13c8ff0c1740406747e28936a4a528
|
|
|
|
|
, EndpointAddress =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EndpointAddress.dhall sha256:8801a741d6efb52835054f88c0b944a684010fe232549644de34d8984291a4f2
|
|
|
|
|
, EndpointPort =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EndpointPort.dhall sha256:f1b394ef30dfe55e080de2712d08bb7005f4f28fb5350d549c87937decc8c4f8
|
|
|
|
|
, EndpointSubset =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EndpointSubset.dhall sha256:bcda3e5ee792842ed616f1b25f351512a248a289ba4054cd605980b5048e5ce3
|
|
|
|
|
, Endpoints =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Endpoints.dhall sha256:540c81fb0bf91d228a0e4b5df30831e5b82584e38cdc18b06a3cbb30d0aea69b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, EndpointsList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.EndpointsList.dhall sha256:d308f3f6b55efa355611addaeaae4a2b11856146f257d7b6c0e3c7077a3c0437
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, EnvFromSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EnvFromSource.dhall sha256:c0dae8d6fda60ec6e15ae2c22db7f0a107ae3202e9d4029438840083d5a9407b
|
|
|
|
|
, EnvVar =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EnvVar.dhall sha256:f2d8ad62f18d6b9a0660f8ebc8ea2b8c3ef6d42bb86a58111791c25c749ed23e
|
|
|
|
|
, EnvVarSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EnvVarSource.dhall sha256:08609b50a26a4ba4b09f2032a6791d5ff7a6a74070a523c8d5912410306d608f
|
|
|
|
|
, Event =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Event.dhall sha256:04cca39a012142f79a25c64ff8a806d4102fcdd8f99848791329d25dd5416874
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, EventList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.EventList.dhall sha256:a89b48d03f842d0727b93f589f03d569d6cc700bfed9efafbf242d755fb30f85
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, EventSeries =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EventSeries.dhall sha256:e0e8307ecdb850c182031d03b5e800f37b5aa65f83e894e31c03ec466c4d2de8
|
|
|
|
|
, EventSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.EventSource.dhall sha256:c6f974a150087cbee63b8ecb26bfefb3e520e0b2f92fb28213934dca9422af08
|
|
|
|
|
, ExecAction =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ExecAction.dhall sha256:87f63b6250ab2ec972de63d7e5123102e5db0c5a4f74d53ac9576c6149efbe36
|
|
|
|
|
, FCVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.FCVolumeSource.dhall sha256:20bf062e62bc83bcbdcb54eac55b348677468091175e5722d43c5661354c7507
|
|
|
|
|
, FlexPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.FlexPersistentVolumeSource.dhall sha256:672bef5b90e0c90b0c2cf56d532aacdf67b4508c66c10aadc9bbfffc571a2fc3
|
|
|
|
|
, FlexVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.FlexVolumeSource.dhall sha256:dda4fdbab8e21578cf38acb3590c6a26d9f107fc274c1938893e141800ae2a38
|
|
|
|
|
, FlockerVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.FlockerVolumeSource.dhall sha256:08040336bf1c3b9a6021dbdd812009cb8d1fb60a2088b0c94c526ad6cd5cf6f1
|
|
|
|
|
, GCEPersistentDiskVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource.dhall sha256:615e35b270fce43209e478f061aa33a4511051080566a27fdabd5f27805d547d
|
|
|
|
|
, GitRepoVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.GitRepoVolumeSource.dhall sha256:74a1d4192937b26b9b417f6e04055b40ce933c3c372d77fb8396d1a876f4e90c
|
|
|
|
|
, GlusterfsPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource.dhall sha256:9d628aecac0c5a08aad9b412e28facbe89c017332fc25f73db10769e251fee6e
|
|
|
|
|
, GlusterfsVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.GlusterfsVolumeSource.dhall sha256:3f3b6353d4261e707e747ca39d47871803e8006597c4d50b46c8bc39f0c4f538
|
|
|
|
|
, HTTPGetAction =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.HTTPGetAction.dhall sha256:1fa81ec4682c3104dc2b8020330a5a6e0e1b2a6162bab678d50c204f2ff34ee1
|
|
|
|
|
, HTTPHeader =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.HTTPHeader.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, Handler =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Handler.dhall sha256:7285cdb4849dec5f0262b7b72870ddbbb374a48511569bd56af66bd90bc58b4e
|
|
|
|
|
, HostAlias =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.HostAlias.dhall sha256:8b7878733ab0ae1e780cbc8fd0c995ed02d2d19b1017512f21a713400633718e
|
|
|
|
|
, HostPathVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.HostPathVolumeSource.dhall sha256:2642b943667e4e1a2f322440adcbc43e2a2f95d98d325c0dc13accb4a4d9ae30
|
|
|
|
|
, ISCSIPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ISCSIPersistentVolumeSource.dhall sha256:cabe8d32c132a4cf5609d8c7ebbe76a1e3dc9355767a9d1bb924a1ab3ee00947
|
|
|
|
|
, ISCSIVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ISCSIVolumeSource.dhall sha256:97874dfed81b1a4970a0a630e19b0f65f943e56aeb36ee9938e5c9f8af8af7bb
|
|
|
|
|
, KeyToPath =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.KeyToPath.dhall sha256:06a424890a609e0d2e3a3bbc64db2a563cabdea47d2bcaed8c1d8deaacffa73b
|
|
|
|
|
, Lifecycle =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Lifecycle.dhall sha256:bcbcd21a0da85d8171931230834d1b88912120c1137a0c5f8b18f0fbd5730209
|
|
|
|
|
, LimitRange =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.LimitRange.dhall sha256:935b30c365528de3bcb4b9eecff9b234e2a2f4042e54e19580c5d8111d17f32d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, LimitRangeItem =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.LimitRangeItem.dhall sha256:f4f2aeee210f914e617f25654a19a8ca9a9145dca6e047863e947d735261f84c
|
|
|
|
|
, LimitRangeList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.LimitRangeList.dhall sha256:a85a861351551adf68a8464122386732ce0874545ce442dc124d12af0423f014
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, LimitRangeSpec =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.LimitRangeSpec.dhall sha256:57ed71870992c11a849da2460191478f3dff503b1daf8694af79385e13f3c987
|
|
|
|
|
, LoadBalancerIngress =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.LoadBalancerIngress.dhall sha256:11aa04f07c5a9df44b1dc56b366ae2c5a66c09320eb7cafb00c80dc5749d15c7
|
|
|
|
|
, LoadBalancerStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.LoadBalancerStatus.dhall sha256:b8b16335fbe8627a2325261ead91f3b996e419749f475ebf90e98fbeb9021ba3
|
|
|
|
|
, LocalObjectReference =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.LocalObjectReference.dhall sha256:018c7b82f7b41ceb9a8d33e0dbd47f7917f486331b6e7a9d0e9573b5f0ff3613
|
|
|
|
|
, LocalVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.LocalVolumeSource.dhall sha256:6bcbb6d925ff77dd1f826b3669a81cd374828b8efa68462a63445c614e0bd5b7
|
|
|
|
|
, NFSVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NFSVolumeSource.dhall sha256:3f3b6353d4261e707e747ca39d47871803e8006597c4d50b46c8bc39f0c4f538
|
|
|
|
|
, Namespace =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Namespace.dhall sha256:03985f8cac622d977b6b2319542e1ba66c0a63241ad77dc2c96aba14e6e6e080
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NamespaceList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.NamespaceList.dhall sha256:7955f05dc9c8681dac36b2de2662b360b5d0204ccb228180f9e8f2f83754dd56
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NamespaceSpec =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NamespaceSpec.dhall sha256:e8e16d18c38bf98ced28e99fad97857e87c48efe61ab9e0d52daa6a6816b97b7
|
|
|
|
|
, NamespaceStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NamespaceStatus.dhall sha256:35dbc3b535620e2c48b2837a5e656e10dd0088e583eebc6d5a519c651c8c455f
|
|
|
|
|
, Node =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Node.dhall sha256:aec20fb0934c709dd7500ba904f2f74b5aaeab577ac34b1e53f93114b918194b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NodeAddress =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeAddress.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, NodeAffinity =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeAffinity.dhall sha256:57b19ab9d887cef469d0288f62c88ff51722079d107d809f6cf8d6191853ed28
|
|
|
|
|
, NodeCondition =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeCondition.dhall sha256:9f6906e25665629d7af729e9eea2139bff347c57f59ee186a50594eb0cdbe1b1
|
|
|
|
|
, NodeConfigSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeConfigSource.dhall sha256:638eb14110525cf40f005bd881fb6ab91661a4bd8acc4f8c2750b191cbcf3aaa
|
|
|
|
|
, NodeConfigStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeConfigStatus.dhall sha256:81efc9ebe97d83fcfc598addaeaacaf6090c6a675f2606eff605e4089ca9d1ca
|
|
|
|
|
, NodeDaemonEndpoints =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeDaemonEndpoints.dhall sha256:e54593e6bac87b9dfd792bbafa69493179b903517c72e11bd860d93bb3bff6c2
|
|
|
|
|
, NodeList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.NodeList.dhall sha256:4fb5f130fbbde720c4f45aecef70f5581abeb2122734ba893e246b49a45a7857
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NodeSelector =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeSelector.dhall sha256:84691e03dc50a1e8fddf88a976145c4d7b424c084cf95c07cbc70536232c6860
|
|
|
|
|
, NodeSelectorRequirement =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeSelectorRequirement.dhall sha256:a73abd30306b4580544d2bba284eb61dac9e405c66e6c585d54aace4bfd9ad20
|
|
|
|
|
, NodeSelectorTerm =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeSelectorTerm.dhall sha256:5e381b5d5e5640455d414cc3f781f8e643eebcf9c9558ee29de92a61f9e49b13
|
|
|
|
|
, NodeSpec =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeSpec.dhall sha256:a4e630a84559a4df6c2e187412b45c9079e834b9addacd6634a96d84a2eaecbd
|
|
|
|
|
, NodeStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeStatus.dhall sha256:272899e67fb0b07864b34e91e445b482b5c9aa593546ba1ba1f17aeda0f61001
|
|
|
|
|
, NodeSystemInfo =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.NodeSystemInfo.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, ObjectFieldSelector =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ObjectFieldSelector.dhall sha256:f7673a492fed0ab5d75b9cfafd00b22399a08a3314a0bfb8fb35f1fb1709cc6b
|
|
|
|
|
, ObjectReference =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ObjectReference.dhall sha256:62fa6130c618b90ef55b9cb2a29e12c7d42045e06fe5ec820d1333315da4e1b7
|
|
|
|
|
, PersistentVolume =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolume.dhall sha256:9ed89bfe6ee3b35629d426c9bc7e55178c5b568ef85a05314f647c9427430973
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PersistentVolumeClaim =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeClaim.dhall sha256:f9e12fa2b68651fe043ec7dd3c1bdeb04682039c978d4bb7b598c30c677cebd7
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PersistentVolumeClaimCondition =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeClaimCondition.dhall sha256:d7a55966e74169d85d6a02388fd65f2759da9f8005cc0be8bee6bed7398af0eb
|
|
|
|
|
, PersistentVolumeClaimList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeClaimList.dhall sha256:24fbeac9a74f02ec3c81be6df71b4beac987d12db816558c9c7e4a3acf1a73ef
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PersistentVolumeClaimSpec =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeClaimSpec.dhall sha256:f2ccc901ad90353c6613c06ab9085ab465481622a76121670b5d6af09e8250d1
|
|
|
|
|
, PersistentVolumeClaimStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeClaimStatus.dhall sha256:b47c19e229c8b096ba674d1072a1e69261c243327837fbc09da22f0c3f10d4f2
|
|
|
|
|
, PersistentVolumeClaimVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource.dhall sha256:3f3b6353d4261e707e747ca39d47871803e8006597c4d50b46c8bc39f0c4f538
|
|
|
|
|
, PersistentVolumeList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeList.dhall sha256:212588783bf8a7ad055b8562793c763b532a55d58f0c2bdd9dfcbc857c900d55
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PersistentVolumeSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeSpec.dhall sha256:5ccf8edbdc59191a9ff0c99a98b86159f0f0048949faf5cf8c6a06d1ca23dee6
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PersistentVolumeStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PersistentVolumeStatus.dhall sha256:0d2b4957e7d170f5025605bff2655625a1ceedc1b3db1921ea1c2f8e7ad3d5a9
|
|
|
|
|
, PhotonPersistentDiskVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource.dhall sha256:6bcbb6d925ff77dd1f826b3669a81cd374828b8efa68462a63445c614e0bd5b7
|
|
|
|
|
, Pod =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Pod.dhall sha256:6da8a242f7164cd6d09e92c5fbb4158ab9f1932a74285d4cee80803127226a0d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodAffinity =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodAffinity.dhall sha256:a352f0c5195d3b3b69899981eb9e930b1023289eaa72858f56dce1d68a4c636e
|
|
|
|
|
, PodAffinityTerm =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodAffinityTerm.dhall sha256:59ace467887b6bcee4807c5b5fedb1076065f3ddb85985e627bf22a280d060d2
|
|
|
|
|
, PodAntiAffinity =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodAntiAffinity.dhall sha256:a352f0c5195d3b3b69899981eb9e930b1023289eaa72858f56dce1d68a4c636e
|
|
|
|
|
, PodCondition =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodCondition.dhall sha256:d7a55966e74169d85d6a02388fd65f2759da9f8005cc0be8bee6bed7398af0eb
|
|
|
|
|
, PodDNSConfig =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodDNSConfig.dhall sha256:b2f87a189bca29e9cfdd23be7f4dfe0805c76be4c55066d405e7f238413d40bb
|
|
|
|
|
, PodDNSConfigOption =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodDNSConfigOption.dhall sha256:b738c3aceed53d603e62521aef6770e70a8ff38982fbd62eb9620833dbfb774b
|
|
|
|
|
, PodList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PodList.dhall sha256:bb7d3028d76343884bd0342868a25884b38b20c6e5265b3d8790a64fd6825534
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodReadinessGate =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodReadinessGate.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, PodSecurityContext =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodSecurityContext.dhall sha256:ef51d449884053ce93f08eeb640b66b5c4bc9c65a64f3388078ac0165fc40bb1
|
|
|
|
|
, PodSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PodSpec.dhall sha256:f19ca75711ca75e40ade52d54ed43a5b24e4f8981f4d0d656d160bb6f5e0ecb2
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PodStatus.dhall sha256:69dccdc3c329799e726a6f38fceafd1e231107e730d63845348c32f10b87b42a
|
|
|
|
|
, PodTemplate =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PodTemplate.dhall sha256:b0680dc4ed6354b2c79f010a548aa00f98f76c6a891c5dd1e862c6353dc5d900
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodTemplateList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PodTemplateList.dhall sha256:2ed6ce2e076c5d90d27963553b2322a50e4602e831f85c4ea71168a3106de7c2
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodTemplateSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.PodTemplateSpec.dhall sha256:668b5e7ed52f7624985559fb4738f46e6bf4eeb245b0c70138677f7413131b43
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PortworxVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PortworxVolumeSource.dhall sha256:5d8e73366d928941a81088f57aaf538a8c3a8d171086228dcefe3aa8084e6a0a
|
|
|
|
|
, PreferredSchedulingTerm =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.PreferredSchedulingTerm.dhall sha256:cced50cd2eefef0a1139f5cefca23b9bb1ba98df472cf6f759d8ecf4bfc3ac80
|
|
|
|
|
, Probe =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Probe.dhall sha256:6a4d14133d4cd7aad81268aab822a31478bda34a37fff10f4113f50c84bb81aa
|
|
|
|
|
, ProjectedVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ProjectedVolumeSource.dhall sha256:277bd19f4e83aba3c285ac8a1532db11ce4de2d62fc4fb1ca39be075bf360564
|
|
|
|
|
, QuobyteVolumeSource =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.QuobyteVolumeSource.dhall sha256:b75569c3c6d18f535f47d3f5675180f7ad4d71f0bf5851c76f6d468307af316c
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RBDPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.RBDPersistentVolumeSource.dhall sha256:343941bb82a82dbc85ef8b28a6d1dfcf3bbb07c8b83efe923d5d7922c2507343
|
|
|
|
|
, RBDVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.RBDVolumeSource.dhall sha256:db8f139715169b2adf35c7b7f2222279fa508c5040737c48f741aaabefdebb33
|
|
|
|
|
, ReplicationController =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ReplicationController.dhall sha256:19df069d161f0528b3144837a5fe98d1be7d04531544feeac86978bfc15b72fa
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ReplicationControllerCondition =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ReplicationControllerCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, ReplicationControllerList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ReplicationControllerList.dhall sha256:05b85f8170c4b813bb1900d4e8fd242625e2e57533f20344098fd39b00265984
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ReplicationControllerSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ReplicationControllerSpec.dhall sha256:c3685eb97c9bee26b3fbe4f6f83f7dc780af8618bdaeee20dc03afeccf70645c
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ReplicationControllerStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ReplicationControllerStatus.dhall sha256:fdf1330beaa8b581ba9a9bdd3976ef99bbf983e17a7a380462acf031f15afe10
|
|
|
|
|
, ResourceFieldSelector =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ResourceFieldSelector.dhall sha256:142c3ef5d0d7c31d4a2e7f12eaef0c0f48215d166701603c8083a536e6274e20
|
|
|
|
|
, ResourceQuota =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ResourceQuota.dhall sha256:924eba6a05643f672a0469bd38a5005ff940f962dfcf31520d2ed71406a01b69
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ResourceQuotaList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ResourceQuotaList.dhall sha256:3297c74902d3d2ee669b3a9ba1016e23bd84476fa78593bdf426eedaf5f70068
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ResourceQuotaSpec =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ResourceQuotaSpec.dhall sha256:f4fbeea8cbf703ab472defb972549856fd79fdc754ef4005710082a780d396b5
|
|
|
|
|
, ResourceQuotaStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ResourceQuotaStatus.dhall sha256:8339ab54c7f9decd48e7e6fc607adc57525e73946b23637146334bed3d461863
|
|
|
|
|
, ResourceRequirements =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ResourceRequirements.dhall sha256:472c8679da2f46473ebee2714e7c26fa85d96097ac27fe743d8b9b6c00947f2c
|
|
|
|
|
, SELinuxOptions =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SELinuxOptions.dhall sha256:26986f88475412dc641d3059e11b41a5b2a9714c0a5bfa82d7f88990b55b2c9e
|
|
|
|
|
, ScaleIOPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource.dhall sha256:0749b51097a37dc83f08ad8fc4ce3f5b4b2bb4419c74711110109aacf6c4c2e6
|
|
|
|
|
, ScaleIOVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ScaleIOVolumeSource.dhall sha256:93b0d2b2b9219158fb48b05f04a018ac824b3f565602f0630496ba6d4aefc53f
|
|
|
|
|
, ScopeSelector =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ScopeSelector.dhall sha256:e9f59488c573165c234e0cd14eb3d6fdc3ab28d97b45d9c37750f8c1589916dc
|
|
|
|
|
, ScopedResourceSelectorRequirement =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ScopedResourceSelectorRequirement.dhall sha256:a73abd30306b4580544d2bba284eb61dac9e405c66e6c585d54aace4bfd9ad20
|
|
|
|
|
, Secret =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Secret.dhall sha256:d81aed05b996c0d63d3887cac2f30bc7d7cbf979d3de216e41b70b6029278d8b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, SecretEnvSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SecretEnvSource.dhall sha256:f48fba5eae86d740341445e19fa71fbf9cfe45d2aff60071682bc95ea7877387
|
|
|
|
|
, SecretKeySelector =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SecretKeySelector.dhall sha256:f48fba5eae86d740341445e19fa71fbf9cfe45d2aff60071682bc95ea7877387
|
|
|
|
|
, SecretList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.SecretList.dhall sha256:ec91a5ffd581f53d245a1faf3f7522ff61db90514e775e9be37221a6a9585c4d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, SecretProjection =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SecretProjection.dhall sha256:7e48f7ea13020516ee9d29255b98f44501fc93dc8982cd23e52e19220ac3d370
|
|
|
|
|
, SecretReference =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SecretReference.dhall sha256:6bafa389265dc30f434cb983275140acb01a4e5406ff88837de788aa2bbc38cf
|
|
|
|
|
, SecretVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SecretVolumeSource.dhall sha256:d6c6371b29e7a110dbc1f75d5476104c2128808fe6146def63cca16a744c4dd2
|
|
|
|
|
, SecurityContext =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SecurityContext.dhall sha256:f7cfd8b258004e117e08157ff15a4b945d7529c04d4c626a8c61158bf77b4ca6
|
|
|
|
|
, Service =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Service.dhall sha256:a509a1220a168b02e4728722d540c9823e2264c5ccb4819c19656951d6afffab
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ServiceAccount =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ServiceAccount.dhall sha256:1520be93f90fcc5e1d9b9ff049aeb79be36ccbca03367064852a76418f9272cc
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ServiceAccountList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ServiceAccountList.dhall sha256:5c3df433e56b4c7f2fa10bfd225c1eb4e3e07332fe16dddd37634edf4546e5ac
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ServiceAccountTokenProjection =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ServiceAccountTokenProjection.dhall sha256:8e0f8a3126dcf4178add5cb1352f244a4eed4e5ebc43719c775d9c5e12263b50
|
|
|
|
|
, ServiceList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.ServiceList.dhall sha256:a7313ccbb6dc87296a3b69e5fa8ab044df34626eaec4d00c12479f96f9d3fdb7
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ServicePort =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ServicePort.dhall sha256:b5b1e54fb82252d691bc3d15a6229f7fcda33f35191e471b81928fd7e6d0137f
|
|
|
|
|
, ServiceSpec =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ServiceSpec.dhall sha256:523ab50cab46ff6219c4823c8ab67ff881ed1a522318ff4801cf1ade919a9e9a
|
|
|
|
|
, ServiceStatus =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.ServiceStatus.dhall sha256:e843ffe274bf4d66ece58d7991f817f98947ff32629954f0cbb82c26a198a78a
|
|
|
|
|
, SessionAffinityConfig =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.SessionAffinityConfig.dhall sha256:73561badbd2aa7cb89da536d1df1cd43c0041d48dc1f956d0837bfa997995c73
|
|
|
|
|
, StorageOSPersistentVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.StorageOSPersistentVolumeSource.dhall sha256:36760d8e32c19223ec9465c23f077c2522ed968edbc89fe3c3bfc06586b5125f
|
|
|
|
|
, StorageOSVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.StorageOSVolumeSource.dhall sha256:d5e6df31f313af87021f1df76e001be05f5cbb6aeef3b171ff09f6ff03066e49
|
|
|
|
|
, Sysctl =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Sysctl.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, TCPSocketAction =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.TCPSocketAction.dhall sha256:e9dc6871c500f86023ae44da8ef71429d8b09de5098f43094b85ae21bf808fc9
|
|
|
|
|
, Taint =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Taint.dhall sha256:addb7c8c98cb125b0108bfdb3a3a872f1e9f0e1b6c57b35aec11da52bbdb2cd3
|
|
|
|
|
, Toleration =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.Toleration.dhall sha256:4f1e8d7c83d46b99c038cf5a4a8ab6cb762c514f747cef05bace9079c634d439
|
|
|
|
|
, TopologySelectorLabelRequirement =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.TopologySelectorLabelRequirement.dhall sha256:a73abd30306b4580544d2bba284eb61dac9e405c66e6c585d54aace4bfd9ad20
|
|
|
|
|
, TopologySelectorTerm =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.TopologySelectorTerm.dhall sha256:d1b32ede0aeaf375a66d74d006a395464259ff4e90c8be96940e83b9ef2ac8d5
|
|
|
|
|
, TypedLocalObjectReference =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.TypedLocalObjectReference.dhall sha256:695fc95850f96c271308d3f68d30fea2627b07f1afed7a7fbee704d69f35aefb
|
|
|
|
|
, Volume =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.Volume.dhall sha256:d9168a9d6e18780e9e042fa706aba1cd12ac5c4053f74525c0f4b49ff7f8387d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, VolumeDevice =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.VolumeDevice.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, VolumeMount =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.core.v1.VolumeMount.dhall sha256:cb70e4e6c9f86a6794a8c4895d4ac4a999a58ff080c9741ea12f3e171ba44a97
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, VolumeNodeAffinity =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.VolumeNodeAffinity.dhall sha256:db1f370292a0476ec09569600a5414b2bdfc0ed4d958a07ecd5ded0c2167aa95
|
|
|
|
|
, VolumeProjection =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.VolumeProjection.dhall sha256:48ace44336d2939870a1c94e7fe481c75a594781f44110d75a28ea7de43a6233
|
|
|
|
|
, VsphereVirtualDiskVolumeSource =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource.dhall sha256:e4f0bb500fd8ef5f2653a8de021370a8d3676ecdafc6fe339d398aace52e0a99
|
|
|
|
|
, WeightedPodAffinityTerm =
|
|
|
|
|
./defaults/io.k8s.api.core.v1.WeightedPodAffinityTerm.dhall sha256:0a99593dd79ccf1f357dab2fcfb5c0a6573dbddec21a9664bb849e8b009d9b33
|
|
|
|
|
, IPBlock =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1.IPBlock.dhall sha256:cc014e7288e2b1bb421317be608236bae1f40bf0d6337af01ab9419bcd6d519a
|
|
|
|
|
, NetworkPolicy =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicy.dhall sha256:9de3a68fc13e5aea227dd17d57301b045fb04794851b9d1b1cf9b8ac76841bdb
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NetworkPolicyEgressRule =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicyEgressRule.dhall sha256:ec183e2fb0b91d4e18fdb3a2ed2c1c0ba17e503d885636c1e307676807e25fc3
|
|
|
|
|
, NetworkPolicyIngressRule =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicyIngressRule.dhall sha256:6497736fe19ada4f1c04f41c450c9cba44b0571bf22b7e53c40e75c3152e6388
|
|
|
|
|
, NetworkPolicyList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicyList.dhall sha256:decaefc444242bca7445fe00db448bc3b77ccb54da25999021463e181b016964
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, NetworkPolicyPeer =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicyPeer.dhall sha256:d6e00f5401a39d211e1da1e910304790f4de6224e37bda55ceea521eadfe510b
|
|
|
|
|
, NetworkPolicyPort =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicyPort.dhall sha256:8ecbd71e633c09b32e9c8f1513dedbfea557a5276c813a7bfd3672b9cab0f53c
|
|
|
|
|
, NetworkPolicySpec =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1.NetworkPolicySpec.dhall sha256:64955dddc8a7a1b07d1f919b22e4d0dc4434b67f13259cd89681f8648932b2fa
|
2019-07-30 10:25:00 +03:00
|
|
|
, HTTPIngressPath =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.HTTPIngressPath.dhall sha256:cf7193b3e867d1c26785aaa920ab8fcb2b193d431712eaee338e538c369f2278
|
|
|
|
|
, HTTPIngressRuleValue =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.HTTPIngressRuleValue.dhall sha256:878fb08cf4d930f63c475ec69e4f34a33918e79fde61ee5184e2564df6c418ed
|
|
|
|
|
, Ingress =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.Ingress.dhall sha256:6d13f39daff533b29f92acb75fd7c405aaf6bd76056c508a833d745e71e0d414
|
|
|
|
|
, IngressBackend =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.IngressBackend.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, IngressList =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.IngressList.dhall sha256:9638ae921b464e41481768537881284dee85f887bf014035c2ab9b782afb4452
|
|
|
|
|
, IngressRule =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.IngressRule.dhall sha256:e78f1b1b9877adaab63d7d529c7cf349b5f79cadea5362e4a20971ee607b3805
|
|
|
|
|
, IngressSpec =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.IngressSpec.dhall sha256:dae09c40d3ded69abdbdcb76a41775595ee739bb52f343c45758b4ed320ad73e
|
|
|
|
|
, IngressStatus =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.IngressStatus.dhall sha256:e843ffe274bf4d66ece58d7991f817f98947ff32629954f0cbb82c26a198a78a
|
|
|
|
|
, IngressTLS =
|
|
|
|
|
./defaults/io.k8s.api.networking.v1beta1.IngressTLS.dhall sha256:602ff9b8f9fc53589735ebedc253c77ff70a1312d3fe4fc0843dcc8d3f60534d
|
|
|
|
|
, RuntimeClassSpec =
|
|
|
|
|
./defaults/io.k8s.api.node.v1alpha1.RuntimeClassSpec.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, RuntimeClass =
|
|
|
|
|
./defaults/io.k8s.api.node.v1beta1.RuntimeClass.dhall sha256:450b4a3d43721d202be829427e0258a1d00a51e50cad8630f5a1728e3ac42bf5
|
|
|
|
|
, RuntimeClassList =
|
|
|
|
|
./defaults/io.k8s.api.node.v1beta1.RuntimeClassList.dhall sha256:55841c7ac9d5a67eed7c0db3b5ccf022783eaf82102d9e28c1d512b7421f0372
|
|
|
|
|
, AllowedCSIDriver =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.AllowedCSIDriver.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, AllowedFlexVolume =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.AllowedFlexVolume.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, AllowedHostPath =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.AllowedHostPath.dhall sha256:3959da80ea35f3736cf00ed1db0cba7c115a841d45b43e01b15d9c4cba4c217b
|
|
|
|
|
, Eviction =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.policy.v1beta1.Eviction.dhall sha256:8c24c76d3e6a04087894937f028028d6f677b420a874ca18ba677fd163dfaf09
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, FSGroupStrategyOptions =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.FSGroupStrategyOptions.dhall sha256:e7710b2c2911ad7bf06ba3638970eea368a0fbd6c9ef4745a06c22efef1a8ffa
|
|
|
|
|
, HostPortRange =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.HostPortRange.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, IDRange =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.IDRange.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, PodDisruptionBudget =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodDisruptionBudget.dhall sha256:15e5058d135770721c06d6eab2f2bb8244467b1303df1e6c7e492b0cdfcc2839
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodDisruptionBudgetList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodDisruptionBudgetList.dhall sha256:123eb2d1d8592e1830822bc29942c7870244c933c4d77eac4f6c546dc163507b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodDisruptionBudgetSpec =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodDisruptionBudgetSpec.dhall sha256:4d43dec438d3737e7d259fe43b0f5cc1227b5d3d8e9638283b58b5eaec70fccb
|
|
|
|
|
, PodDisruptionBudgetStatus =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodDisruptionBudgetStatus.dhall sha256:5e7d8a7a349bb8a9fa429474c5249c73a7617e122fac24d186136cf3fa0335e0
|
|
|
|
|
, PodSecurityPolicy =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodSecurityPolicy.dhall sha256:c18a026ec1e8f7db9ff03d1a772accac3f34e91b38ed88172c883e9ee6a75d83
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodSecurityPolicyList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodSecurityPolicyList.dhall sha256:5abdf4100036cbfb510366e7b03eaaa974f7b94fc64f4c1fb77ff223bad98e64
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodSecurityPolicySpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.policy.v1beta1.PodSecurityPolicySpec.dhall sha256:4a1bf37f2b5489ab49c1d4af4c633e12e9c9eea970921adff35a7bc5bec50471
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RunAsGroupStrategyOptions =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.RunAsGroupStrategyOptions.dhall sha256:c5a2b1471ef3700443a5ed1e59a47e640ffd392c3eeb275d223c0a4ef95450ae
|
|
|
|
|
, RunAsUserStrategyOptions =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.RunAsUserStrategyOptions.dhall sha256:c5a2b1471ef3700443a5ed1e59a47e640ffd392c3eeb275d223c0a4ef95450ae
|
|
|
|
|
, SELinuxStrategyOptions =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.SELinuxStrategyOptions.dhall sha256:4f75cf22af14786a303d47531c790359d1d9bf27cb7560d715a1a47ce38533d6
|
|
|
|
|
, SupplementalGroupsStrategyOptions =
|
|
|
|
|
./defaults/io.k8s.api.policy.v1beta1.SupplementalGroupsStrategyOptions.dhall sha256:e7710b2c2911ad7bf06ba3638970eea368a0fbd6c9ef4745a06c22efef1a8ffa
|
|
|
|
|
, AggregationRule =
|
|
|
|
|
./defaults/io.k8s.api.rbac.v1.AggregationRule.dhall sha256:eda7bc9d540e37e4b70193988a23b84e618ebc279aec5f82726f87da169ca1bd
|
|
|
|
|
, ClusterRole =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.ClusterRole.dhall sha256:d85debf484ce519e28febf09abb015816d99dc48fd9fb4c675460886a03402e0
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ClusterRoleBinding =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.ClusterRoleBinding.dhall sha256:30a51314a9df30a588bbfebbf61747c0ebfd665f0dcefa3d27d24c59b783396f
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ClusterRoleBindingList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.ClusterRoleBindingList.dhall sha256:ba0b07ca5297b2486eb0bb024e3f1a5d06608ff17c3ac3ef0b643e3bc08ab81d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ClusterRoleList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.ClusterRoleList.dhall sha256:2a9b63be639cebe6bc8806d34ba7060ce69afda703c6d982b0b7f919c927d78c
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PolicyRule =
|
|
|
|
|
./defaults/io.k8s.api.rbac.v1.PolicyRule.dhall sha256:f1e80eaa23351d9db2be03f4e2fe23b3f6944e9ff98369c8d2d9f547b13a4e54
|
|
|
|
|
, Role =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.Role.dhall sha256:2f993bbc2557976afd433521c4b5618f336e4b9a073d4c835313639b4764d7c1
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RoleBinding =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.RoleBinding.dhall sha256:c4935f8f14f9a2c8211e088b07160386ac39e0464fbfd16c2f62c2694da8a332
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RoleBindingList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.RoleBindingList.dhall sha256:2bd02ba6184c32214bf303d0e1b15ac75747138da460450fd6f6ca28bfd531f7
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RoleList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.rbac.v1.RoleList.dhall sha256:9873186b8be56c17e539e5f2ee9d75c0239805615d8a403dd3258521caaa34b5
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, RoleRef =
|
|
|
|
|
./defaults/io.k8s.api.rbac.v1.RoleRef.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, Subject =
|
|
|
|
|
./defaults/io.k8s.api.rbac.v1.Subject.dhall sha256:5dba58bbc3868cce8a9783623feb8a4d329487e6f2fb5c9082fb64fe69c8c4cb
|
|
|
|
|
, PriorityClass =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.scheduling.v1.PriorityClass.dhall sha256:298f51cbdf478058913b7d135bc68a27402a321fe68ab700bf1b32343d94c886
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PriorityClassList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.scheduling.v1.PriorityClassList.dhall sha256:3240a7774a57cd72d167073c482c394cc437a10b925dd0ed7393598671eb1090
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodPreset =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.settings.v1alpha1.PodPreset.dhall sha256:292c22cf3ebad2b52928eebf9befddf04f48f459818c806f09794ee35dacb47d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodPresetList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.settings.v1alpha1.PodPresetList.dhall sha256:7a74b876b677043903e5101f819a1632e5590a071e01d36b1cd061a915ebac01
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, PodPresetSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.settings.v1alpha1.PodPresetSpec.dhall sha256:55c5315fd05e5f78c624c651859ce9ae0ad0ff13f64fcc7cd7313a331732256c
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, StorageClass =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.storage.v1.StorageClass.dhall sha256:e53c737a6e74f5819e3380a4972acb13e54a6f7437de4401c5a5fbead80dcf56
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, StorageClassList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.storage.v1.StorageClassList.dhall sha256:e4615fb12875e763b58bbf48880dbe6636d72bf1669ed577f357a95ae81eaeaf
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, VolumeAttachment =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.storage.v1.VolumeAttachment.dhall sha256:9cdd608f8cd2bf94e330c59adf52b3e5e1c6c0eba3f7a69fd8a54189065a92af
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, VolumeAttachmentList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.api.storage.v1.VolumeAttachmentList.dhall sha256:91bdc7669edd07cc2ffad697d4b6efc23751ba223290720a5762664c10c96c16
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, VolumeAttachmentSource =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1.VolumeAttachmentSource.dhall sha256:1182fd42dcc5bc0f940566182920b2db83e385a55eb6fa38ced55c39baf42c3c
|
|
|
|
|
, VolumeAttachmentSpec =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1.VolumeAttachmentSpec.dhall sha256:f4cedf2a5fa63ee777f750bbb8ead1ee07f3b4e13e210e300ebb858e606e33a2
|
|
|
|
|
, VolumeAttachmentStatus =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1.VolumeAttachmentStatus.dhall sha256:8f4cb992de940a61b392be71f6a720d80e20e8c0fbd47189bbb41f09910bd7ab
|
|
|
|
|
, VolumeError =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1.VolumeError.dhall sha256:cf06366750591e3481de59fd7f53bbf03e9008836429cdb7e7d95fcb4dd96977
|
2019-07-30 10:25:00 +03:00
|
|
|
, CSIDriver =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSIDriver.dhall sha256:7ce9926844835fdd3a1634e5f2c23e4a37790aba9c9b94ddfbeacc831b2ede4c
|
|
|
|
|
, CSIDriverList =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSIDriverList.dhall sha256:56c27639aa7469cfd21dfe8569abbed9cbd61322f1c54f428b67bd34c3e8473c
|
|
|
|
|
, CSIDriverSpec =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSIDriverSpec.dhall sha256:5ab70bfd0392fdcad3a4f6e417441933d3f99da89e0cd07844cbf2d00ea0dcf2
|
|
|
|
|
, CSINode =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSINode.dhall sha256:2fc7ce5159897cee24f2d19cf5fff00c6edd47dedb0fe71c76d24738e6465fdd
|
|
|
|
|
, CSINodeDriver =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSINodeDriver.dhall sha256:cff8d57365c1b4f8f5df7273cb7d20995cbe3455568fd1d149f7d81560240152
|
|
|
|
|
, CSINodeList =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSINodeList.dhall sha256:478f300c120d102129ff006e2d8bdedfc9163bf72946de2cfe54828ecd183e05
|
|
|
|
|
, CSINodeSpec =
|
|
|
|
|
./defaults/io.k8s.api.storage.v1beta1.CSINodeSpec.dhall sha256:e3da591ad08d03dae369987ecbcd2d2632e4aa487640d79fb4c77bffe48bf460
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceColumnDefinition =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceColumnDefinition.dhall sha256:da33c0d8b175d341f3bdf8cf9670bccbb3f1e1ce8e134c6ef32c01927886b2e7
|
|
|
|
|
, CustomResourceConversion =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceConversion.dhall sha256:a6c7839d4b7c41a40e2c25e6ea363004013ce8c07a85f174ea07b1161d6274b4
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceDefinition =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinition.dhall sha256:546febaaec290dacf374ed5c4d4a7483f64a1393991a881c8aec7f25d690cc8b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceDefinitionCondition =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, CustomResourceDefinitionList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionList.dhall sha256:00a6666ad8d230e58c4bb85de1bab49c2477cd8ab0519e9e1edda62088578478
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceDefinitionNames =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionNames.dhall sha256:73f1528045b5541c009f74e02026661616223dc23bc0df9c0d640fd0184eef0a
|
|
|
|
|
, CustomResourceDefinitionSpec =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionSpec.dhall sha256:4d838df70112a465e8176e65e6adf47104ffc7e649c989da67a81be4d0d064f4
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceDefinitionStatus =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionStatus.dhall sha256:318553c0327930257e05495251cafe571a94670e29285b7aa6b834cea63ac849
|
|
|
|
|
, CustomResourceDefinitionVersion =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionVersion.dhall sha256:f38f02e071101b1bbde87556d376a2eaabd86d2257ef98da689b1f13bb38b99e
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceSubresourceScale =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresourceScale.dhall sha256:265a09b4bd7a8452253edec4c5a15e1d9f8c4805350ac7b19fac74eca23b266e
|
|
|
|
|
, CustomResourceSubresources =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresources.dhall sha256:9ae05caacec1bcc4f030d8eef9b82d5416b9f22134b108c7db6b56c859d86ba3
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, CustomResourceValidation =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceValidation.dhall sha256:63a5fcf89cb9de2d22b7efc65ee01f28713bd08493785fbfbd06fc4dbae52224
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ExternalDocumentation =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.ExternalDocumentation.dhall sha256:ef72045716c5bc714c4a81aa7218ade9eec702588c9a2650fe5b7d6331445032
|
|
|
|
|
, JSON =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSON.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, JSONSchemaProps =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps.dhall sha256:197810be536128b4562653c9cf2ff9c28b2afd3b1307496c6335f870336e707b
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, JSONSchemaPropsOrArray =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrArray.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, JSONSchemaPropsOrBool =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrBool.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, JSONSchemaPropsOrStringArray =
|
|
|
|
|
./defaults/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrStringArray.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, APIGroup =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup.dhall sha256:019e584fbf0d07d8041ecd5ad6fa4cd1884912aab2f09b29c96709688ea9da47
|
|
|
|
|
, APIGroupList =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroupList.dhall sha256:7f9a7e759a6ad1311517cac484bc7428a80ec7930154c083ebde4e96ba86c5dc
|
|
|
|
|
, APIResource =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource.dhall sha256:7b7fbd8efa451a3f31acecf6e66acb49f534784c5d6e12d12e06b2f4f0c1afe2
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, APIResourceList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList.dhall sha256:3974ea7777e068fa5c18488a5e9371e76f788229c14aed2f7e804c14c503216d
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, APIVersions =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions.dhall sha256:60a54bb5657a95095b1d2c146cc158de2d0bb543aa8a5bb5ddcf4cdc960ce261
|
|
|
|
|
, DeleteOptions =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions.dhall sha256:baf58acb2428a2e4f910d3d58e1ad7033a13730e3143979e5e3d8e0dce351965
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, GroupVersionForDiscovery =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, Initializer =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.Initializer.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, Initializers =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.Initializers.dhall sha256:8778da99ce0d2e7a6061694ce8784c0d302e6ad6642a8dcb4f7f0dbaf044db6a
|
|
|
|
|
, LabelSelector =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector.dhall sha256:40c91f2f9e8af96f9ddfc5b352b5b7f5d735c16bd974bb9241b8dd49f83e952c
|
|
|
|
|
, LabelSelectorRequirement =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement.dhall sha256:a73abd30306b4580544d2bba284eb61dac9e405c66e6c585d54aace4bfd9ad20
|
|
|
|
|
, ListMeta =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta.dhall sha256:8e0be93a427da54fad7c8d33f44bc78e8d07923b25674a3029eda40ad763b2c9
|
2019-07-30 10:25:00 +03:00
|
|
|
, ManagedFieldsEntry =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry.dhall sha256:643540c24702375834074b3cb02bb06c142336d6ef34605a5db9a08105b6f058
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ObjectMeta =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta.dhall sha256:83c9abeaa54bdf36310fb0c8e2fa34807d7a6eed036a787e831ae7b78f1933a4
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, OwnerReference =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference.dhall sha256:f70106741b413c2392e0e02bf4231e46d425c4490419f312a00798131e23c5c6
|
|
|
|
|
, Preconditions =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions.dhall sha256:3d113c81519001211e7181315ce43d0cea7e2edd45757b14ac3fbe2b0927f605
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, ServerAddressByClientCIDR =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, Status =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.Status.dhall sha256:a3e20d01832b7d7d6141b85e964d2744c9226f1e521242b19329256491d104d2
|
|
|
|
|
, StatusCause =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause.dhall sha256:a4aacae516d651f61fb8dc5c2f3fc2be64604f211f68f378a1166c7136cb5c16
|
|
|
|
|
, StatusDetails =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails.dhall sha256:d7273e299826f59501871061aa574e0c16830595b016e23782bc81ffafa3d712
|
|
|
|
|
, WatchEvent =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent.dhall sha256:d8f8f8dce17b8cec5ae1045a450153d2bb6de52cffb7bad2bbc259213747f6fa
|
|
|
|
|
, RawExtension =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.runtime.RawExtension.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, Info =
|
|
|
|
|
./defaults/io.k8s.apimachinery.pkg.version.Info.dhall sha256:9bb9dcb5bf6f795291686f59383bcd01c8e79b87fc3fb63351d46dea100ac51b
|
|
|
|
|
, APIService =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService.dhall sha256:c0eaa9018940aed57c7aca7bde26a21398bc7d01c363358675c3b477c39530d3
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, APIServiceCondition =
|
|
|
|
|
./defaults/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition.dhall sha256:fef63958bc998f900417bd68974df7936535249af83edf1183721637fa3e7257
|
|
|
|
|
, APIServiceList =
|
2019-07-30 10:25:00 +03:00
|
|
|
./defaults/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList.dhall sha256:857f9e53bf7d33f6675ed5faaf701bc0fddf1701aa80ce653ef6a49dab74410e
|
API v2 (#57)
This ports the conversion script from Python to Haskell (fix #7)
The main reasons for this port are that:
- the Python script was really hard to maintain for reasons like
"converting from Swagger to Dhall is interleaved with string formatting"
- in Haskell we can use the dhall library to generate always syntactically
correct Dhall AST. It's also much easier to keep an eye on correctness,
because types and pattern matching. It also forces us to deal with things
like cyclic imports from the get go.
Things happening here:
- remove the `api` folder, removing the difference between "raw api" and "nice api"
- move defaults from `default` to `defaults` folder, as it is in `dhall-nethack`
- transition to the new syntax for `Optional` (fix #49)
- add `types.dhall` and `defaults.dhall`, so that one can now easily "pin a version"
by just importing these two records at a specific commit/tag. They also make it really
easy to access objects, e.g.
`let types = https://raw.githubusercontent... sha256:... in types.Deployment`
- also add typesUnion.dhall (fix #54), so one is able to send to Kubernetes different
objects in the same stream. This is also documented in the README
- defaults are resolved recursively (fix #46): if there's an import of a "nullable" record,
then it's not marked as Optional, making merging objects much easier
- default objects are not lambdas anymore, and instead they just don't include the required
fields (that is, the ones that are not nullable records), as suggested in dhall-lang/dhall-lang#382
- for objects that are simple types we used to generate a simple lambda
`\(a : Text) -> a` as a default, now we just don't generate a default (e.g. see
`io.k8s.apimachinery.pkg.apis.meta.v1.Time`)
- autoformat all generated Dhall code
- remove cyclic imports (fix #47)
- update to dhall-1.22 and dhall-json-1.2.8
2019-05-01 19:13:18 +03:00
|
|
|
, APIServiceSpec =
|
|
|
|
|
./defaults/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec.dhall sha256:46c90820ac80a5073a7750517ae48ba24ec487bd7c6cf118d11e36bce11022f9
|
|
|
|
|
, APIServiceStatus =
|
|
|
|
|
./defaults/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus.dhall sha256:095c10d7c74ad63f074a1a78327080a6854b28a6656fb0551127d8aea344c374
|
|
|
|
|
, ServiceReference =
|
|
|
|
|
./defaults/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference.dhall sha256:6bafa389265dc30f434cb983275140acb01a4e5406ff88837de788aa2bbc38cf
|
|
|
|
|
}
|
