@cat-factory/contracts 0.339.0 → 0.341.0

package/dist/environments.d.ts

@@ -136,6 +136,20 @@ export declare const environmentResponseMappingSchema: v.ObjectSchema<{
      * is the only thing to try.
      */
     readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * The same, for a management API that identifies those balancers by NAME: a string, an array of
+     * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+     * dials, and grades every address it answers with exactly as a stated address is graded.
+     *
+     * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+     * already means an address and cannot be re-read as a name without guessing: a manifest saying
+     * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+     * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+     * addresses are then tried ahead of the names; a provider that wants a different order between
+     * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+     * is the one shape that can interleave them.
+     */
+    readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
         readonly from: v.StringSchema<undefined>;
@@ -262,6 +276,20 @@ export declare const environmentManifestSchema: v.ObjectSchema<{
          * is the only thing to try.
          */
         readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The same, for a management API that identifies those balancers by NAME: a string, an array of
+         * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+         * dials, and grades every address it answers with exactly as a stated address is graded.
+         *
+         * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+         * already means an address and cannot be re-read as a name without guessing: a manifest saying
+         * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+         * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+         * addresses are then tried ahead of the names; a provider that wants a different order between
+         * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+         * is the one shape that can interleave them.
+         */
+        readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
             readonly from: v.StringSchema<undefined>;
@@ -557,6 +585,20 @@ export declare const environmentBackendConfigSchema: v.VariantSchema<"kind", [v.
              * is the only thing to try.
              */
             readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The same, for a management API that identifies those balancers by NAME: a string, an array of
+             * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+             * dials, and grades every address it answers with exactly as a stated address is graded.
+             *
+             * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+             * already means an address and cannot be re-read as a name without guessing: a manifest saying
+             * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+             * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+             * addresses are then tried ahead of the names; a provider that wants a different order between
+             * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+             * is the one shape that can interleave them.
+             */
+            readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                 readonly from: v.StringSchema<undefined>;
@@ -962,6 +1004,20 @@ export declare const environmentBackendConfigSchema: v.VariantSchema<"kind", [v.
              * is the only thing to try.
              */
             readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The same, for a management API that identifies those balancers by NAME: a string, an array of
+             * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+             * dials, and grades every address it answers with exactly as a stated address is graded.
+             *
+             * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+             * already means an address and cannot be re-read as a name without guessing: a manifest saying
+             * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+             * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+             * addresses are then tried ahead of the names; a provider that wants a different order between
+             * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+             * is the one shape that can interleave them.
+             */
+            readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                 readonly from: v.StringSchema<undefined>;
@@ -1463,6 +1519,20 @@ export declare const infraHandlerConfigSchema: v.VariantSchema<"engine", [v.Obje
              * is the only thing to try.
              */
             readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The same, for a management API that identifies those balancers by NAME: a string, an array of
+             * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+             * dials, and grades every address it answers with exactly as a stated address is graded.
+             *
+             * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+             * already means an address and cannot be re-read as a name without guessing: a manifest saying
+             * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+             * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+             * addresses are then tried ahead of the names; a provider that wants a different order between
+             * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+             * is the one shape that can interleave them.
+             */
+            readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                 readonly from: v.StringSchema<undefined>;
@@ -1795,6 +1865,20 @@ export declare const infraHandlerConfigSchema: v.VariantSchema<"engine", [v.Obje
              * is the only thing to try.
              */
             readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The same, for a management API that identifies those balancers by NAME: a string, an array of
+             * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+             * dials, and grades every address it answers with exactly as a stated address is graded.
+             *
+             * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+             * already means an address and cannot be re-read as a name without guessing: a manifest saying
+             * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+             * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+             * addresses are then tried ahead of the names; a provider that wants a different order between
+             * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+             * is the one shape that can interleave them.
+             */
+            readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                 readonly from: v.StringSchema<undefined>;
@@ -1997,6 +2081,20 @@ export declare const environmentHandlerViewSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -2329,6 +2427,20 @@ export declare const environmentHandlerViewSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -2485,6 +2597,20 @@ export declare const registerEnvironmentHandlerSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -2817,6 +2943,20 @@ export declare const registerEnvironmentHandlerSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -2973,6 +3113,20 @@ export declare const testEnvironmentHandlerSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -3305,6 +3459,20 @@ export declare const testEnvironmentHandlerSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -3462,6 +3630,20 @@ export declare const upsertEnvironmentUserHandlerBodySchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -3794,6 +3976,20 @@ export declare const upsertEnvironmentUserHandlerBodySchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -3966,6 +4162,20 @@ export declare const environmentHandlersBundleSchema: v.ObjectSchema<{
                      * is the only thing to try.
                      */
                     readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    /**
+                     * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                     * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                     * dials, and grades every address it answers with exactly as a stated address is graded.
+                     *
+                     * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                     * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                     * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                     * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                     * addresses are then tried ahead of the names; a provider that wants a different order between
+                     * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                     * is the one shape that can interleave them.
+                     */
+                    readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                         readonly from: v.StringSchema<undefined>;
@@ -4298,6 +4508,20 @@ export declare const environmentHandlersBundleSchema: v.ObjectSchema<{
                      * is the only thing to try.
                      */
                     readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    /**
+                     * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                     * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                     * dials, and grades every address it answers with exactly as a stated address is graded.
+                     *
+                     * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                     * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                     * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                     * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                     * addresses are then tried ahead of the names; a provider that wants a different order between
+                     * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                     * is the one shape that can interleave them.
+                     */
+                    readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                         readonly from: v.StringSchema<undefined>;
@@ -4396,12 +4620,14 @@ export declare const environmentHandleSchema: v.ObjectSchema<{
      */
     readonly reachability: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
         readonly candidates: v.ArraySchema<v.ObjectSchema<{
-            readonly address: v.StringSchema<undefined>;
+            readonly address: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly host: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         }, undefined>, undefined>;
         readonly proof: v.NullableSchema<v.ObjectSchema<{
             readonly state: v.PicklistSchema<["reached", "not_reached", "inconclusive", "unproved"], undefined>;
             readonly via: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly viaHost: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly reason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly attempts: v.ArraySchema<v.ObjectSchema<{
                 readonly target: v.StringSchema<undefined>;
@@ -4589,6 +4815,20 @@ export declare const environmentConnectionSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -4994,6 +5234,20 @@ export declare const environmentConnectionSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -5148,6 +5402,20 @@ export declare const registerEnvironmentProviderSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -5553,6 +5821,20 @@ export declare const registerEnvironmentProviderSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -5709,6 +5991,20 @@ export declare const testEnvironmentConnectionSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;
@@ -6114,6 +6410,20 @@ export declare const testEnvironmentConnectionSchema: v.ObjectSchema<{
                  * is the only thing to try.
                  */
                 readonly addressesPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The same, for a management API that identifies those balancers by NAME: a string, an array of
+                 * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+                 * dials, and grades every address it answers with exactly as a stated address is graded.
+                 *
+                 * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+                 * already means an address and cannot be re-read as a name without guessing: a manifest saying
+                 * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+                 * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+                 * addresses are then tried ahead of the names; a provider that wants a different order between
+                 * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+                 * is the one shape that can interleave them.
+                 */
+                readonly hostsPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly statusMap: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
                     readonly from: v.StringSchema<undefined>;

package/dist/environments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environments.d.ts","sourceRoot":"","sources":["../src/environments.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"environments.d.ts","sourceRoot":"","sources":["../src/environments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAuC5B;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;IAMpC,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAqBtE,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF,eAAO,MAAM,2BAA2B,wEAAwD,CAAA;AAChG,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;IAM3C,uEAAuE;;aAEvE,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE/F,oEAAoE;AACpE,eAAO,MAAM,uBAAuB,0GAOlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,0BAA0B,6FAKrC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF,eAAO,MAAM,6BAA6B,2EAKxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;;aAOzC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;GAIG;AACH,eAAO,MAAM,gCAAgC;;IAE3C;;;;;;;;;OASG;;IAEH;;;;;;;;;;;;OAYG;;;;;;;;;;;;;;;;;aAOH,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE/F,iFAAiF;AACjF,eAAO,MAAM,yBAAyB;;;IAGpC,+EAA+E;;;;;;;;;;QA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwCtE,uEAAuE;;;IAuHvE,+DAA+D;;;;;;;;;;;;;QAvH/D,uEAAuE;;;IAyHvE,6EAA6E;;;;;;;;;;;;;QAzH7E,uEAAuE;;;;;QA8EvE;;;;;;;;;WASG;;QAEH;;;;;;;;;;;;WAYG;;;;;;;;;;;;;;;;;;IAuBH,sEAAsE;;IAEtE;;;;;;;;;;;OAWG;;aAEH,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAajF;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,oGAM9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,8BAA8B,8QAYzC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AA0C3F,gGAAgG;AAChG,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,MAAM,IAAI,wBAAwB,CAGpC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,wHAO5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,4DAA4D;AAC5D,eAAO,MAAM,gBAAgB,6KAK5B,CAAA;AACD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAkB/D,qFAAqF;AACrF,eAAO,MAAM,+BAA+B,gBAAgB,CAAA;AAE5D,iGAAiG;AACjG,eAAO,MAAM,uCAAuC,kCAAkC,CAAA;AACtF,eAAO,MAAM,4CAA4C,sBAAsB,CAAA;AAkB/E;;;;;;;;;GASG;AACH,eAAO,MAAM,gCAAgC;IAC3C,4FAA4F;;aAE5F,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE/F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iCAAiC;IAhB5C,4FAA4F;;;IAmB5F;;;;;OAKG;;IAWH;;;;OAIG;;IAIH,kGAAkG;;IAElG,0EAA0E;;IAE1E,kEAAkE;;aAElE,CAAA;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAEjG,qEAAqE;AACrE,eAAO,MAAM,kCAAkC,YAC7C,UAAU,EACV,YAAY,EACZ,KAAK,EACL,YAAY,CACJ,CAAA;AAEV;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,8PAE9C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B;;;;;QArUzC,+EAA+E;;;;;;;;;;YA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwCtE,uEAAuE;;;QAuHvE,+DAA+D;;;;;;;;;;;;;YAvH/D,uEAAuE;;;QAyHvE,6EAA6E;;;;;;;;;;;;;YAzH7E,uEAAuE;;;;;YA8EvE;;;;;;;;;eASG;;YAEH;;;;;;;;;;;;eAYG;;;;;;;;;;;;;;;;;;QAuBH,sEAAsE;;QAEtE;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6NH,4FAA4F;;;QAmB5F;;;;;WAKG;;QAWH;;;;WAIG;;QAIH,kGAAkG;;QAElG,0EAA0E;;QAE1E,kEAAkE;;;;;;;;QAlSlE,+EAA+E;;;;;;;;;;YA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwCtE,uEAAuE;;;QAuHvE,+DAA+D;;;;;;;;;;;;;YAvH/D,uEAAuE;;;QAyHvE,6EAA6E;;;;;;;;;;;;;YAzH7E,uEAAuE;;;;;YA8EvE;;;;;;;;;eASG;;YAEH;;;;;;;;;;;;eAYG;;;;;;;;;;;;;;;;;;QAuBH,sEAAsE;;QAEtE;;;;;;;;;;;WAWG;;;0BAqTH,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC3F,MAAM,MAAM,sBAAsB,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAA;AAMrE;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;IAEpC,oGAAoG;;;;;;;;;;;;IAEpG,4EAA4E;;IAE5E,oFAAoF;;IAEpF;;;;;OAKG;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH,wGAAwG;;IAExG,sEAAsE;;IAEtE;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIH,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAMjF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B;;IAEvC,uEAAuE;;IAEvE,4FAA4F;;IAE5F,sFAAsF;;IAEtF;;;;;;OAMG;;IAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;IAEvD,+EAA+E;;IAE/E,kEAAkE;;IAElE;;;;OAIG;;IAEH,sEAAsE;;IAEtE,kDAAkD;;IAElD;;;;;OAKG;;;;;;;;;;;;;;;;;;;;aAEH,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;QA1bnC,+EAA+E;;;;;;;;;;YA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwCtE,uEAAuE;;;QAuHvE,+DAA+D;;;;;;;;;;;;;YAvH/D,uEAAuE;;;QAyHvE,6EAA6E;;;;;;;;;;;;;YAzH7E,uEAAuE;;;;;YA8EvE;;;;;;;;;eASG;;YAEH;;;;;;;;;;;;eAYG;;;;;;;;;;;;;;;;;;QAuBH,sEAAsE;;QAEtE;;;;;;;;;;;WAWG;;;;;;;QAqXH,uEAAuE;;QAEvE,4FAA4F;;QAE5F,sFAAsF;;QAEtF;;;;;;WAMG;;QAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;QAEvD,+EAA+E;;QAE/E,kEAAkE;;QAElE;;;;WAIG;;QAEH,sEAAsE;;QAEtE,kDAAkD;;QAElD;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;QAnCH,uEAAuE;;QAEvE,4FAA4F;;QAE5F,sFAAsF;;QAEtF;;;;;;WAMG;;QAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;QAEvD,+EAA+E;;QAE/E,kEAAkE;;QAElE;;;;WAIG;;QAEH,sEAAsE;;QAEtE,kDAAkD;;QAElD;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;QA3LH,4FAA4F;;;QAmB5F;;;;;WAKG;;QAWH;;;;WAIG;;QAIH,kGAAkG;;QAElG,0EAA0E;;QAE1E,kEAAkE;;;;;;;;QAlSlE,+EAA+E;;;;;;;;;;YA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwCtE,uEAAuE;;;QAuHvE,+DAA+D;;;;;;;;;;;;;YAvH/D,uEAAuE;;;QAyHvE,6EAA6E;;;;;;;;;;;;;YAzH7E,uEAAuE;;;;;YA8EvE;;;;;;;;;eASG;;YAEH;;;;;;;;;;;;eAYG;;;;;;;;;;;;;;;;;;QAuBH,sEAAsE;;QAEtE;;;;;;;;;;;WAWG;;;IA4aD,uGAAuG;;0BAGzG,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAO/E,eAAO,MAAM,8BAA8B,0DAA0C,CAAA;AACrF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F,6FAA6F;AAC7F,eAAO,MAAM,wBAAwB;;;IAGnC,uEAAuE;;IAEvE,qEAAqE;;;IAGrE;;;;OAIG;;IAEH;;;;OAIG;;aAEH,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,sEAAsE;AACtE,eAAO,MAAM,8BAA8B;;;;;;aAMzC,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAOhG,iFAAiF;AACjF,eAAO,MAAM,4BAA4B;;IAEvC,gFAAgF;;;;;;;IAOhF,+EAA+E;;IAE/E,oFAAoF;;IAEpF;;;;;OAKG;;IAEH,iFAAiF;;;;;;YA5gBjF,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;YAqXH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;;YAnCH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;YA3LH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;QA4aD,uGAAuG;;;aA4EzG,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;YAvhB3C,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;YAqXH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;;YAnCH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;YA3LH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;QA4aD,uGAAuG;;;;;aA2FzG,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAEpG;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B;;;;;;YAtiBvC,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;YAqXH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;;YAnCH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;YA3LH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;QA4aD,uGAAuG;;;;;aAwGzG,CAAA;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE5F;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC;;;;;;;YAnjBjD,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;YAqXH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;;YAnCH,uEAAuE;;YAEvE,4FAA4F;;YAE5F,sFAAsF;;YAEtF;;;;;;eAMG;;YAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;YAEvD,+EAA+E;;YAE/E,kEAAkE;;YAElE;;;;eAIG;;YAEH,sEAAsE;;YAEtE,kDAAkD;;YAElD;;;;;eAKG;;;;;;;;;;;;;;;;;;;;;;;;YA3LH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;QA4aD,uGAAuG;;;;;aAsHzG,CAAA;AACF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,WAAW,CAC1D,OAAO,sCAAsC,CAC9C,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,+BAA+B;;;QApE1C,gFAAgF;;;;;;;QAOhF,+EAA+E;;QAE/E,oFAAoF;;QAEpF;;;;;WAKG;;QAEH,iFAAiF;;;;;;gBA5gBjF,+EAA+E;;;;;;;;;;oBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCtE,uEAAuE;;;gBAuHvE,+DAA+D;;;;;;;;;;;;;oBAvH/D,uEAAuE;;;gBAyHvE,6EAA6E;;;;;;;;;;;;;oBAzH7E,uEAAuE;;;;;oBA8EvE;;;;;;;;;uBASG;;oBAEH;;;;;;;;;;;;uBAYG;;;;;;;;;;;;;;;;;;gBAuBH,sEAAsE;;gBAEtE;;;;;;;;;;;mBAWG;;;;;;;gBAqXH,uEAAuE;;gBAEvE,4FAA4F;;gBAE5F,sFAAsF;;gBAEtF;;;;;;mBAMG;;gBAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;gBAEvD,+EAA+E;;gBAE/E,kEAAkE;;gBAElE;;;;mBAIG;;gBAEH,sEAAsE;;gBAEtE,kDAAkD;;gBAElD;;;;;mBAKG;;;;;;;;;;;;;;;;;;;;;;;;;gBAnCH,uEAAuE;;gBAEvE,4FAA4F;;gBAE5F,sFAAsF;;gBAEtF;;;;;;mBAMG;;gBAEH,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;gBAEvD,+EAA+E;;gBAE/E,kEAAkE;;gBAElE;;;;mBAIG;;gBAEH,sEAAsE;;gBAEtE,kDAAkD;;gBAElD;;;;;mBAKG;;;;;;;;;;;;;;;;;;;;;;;;gBA3LH,4FAA4F;;;gBAmB5F;;;;;mBAKG;;gBAWH;;;;mBAIG;;gBAIH,kGAAkG;;gBAElG,0EAA0E;;gBAE1E,kEAAkE;;;;;;;;gBAlSlE,+EAA+E;;;;;;;;;;oBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCtE,uEAAuE;;;gBAuHvE,+DAA+D;;;;;;;;;;;;;oBAvH/D,uEAAuE;;;gBAyHvE,6EAA6E;;;;;;;;;;;;;oBAzH7E,uEAAuE;;;;;oBA8EvE;;;;;;;;;uBASG;;oBAEH;;;;;;;;;;;;uBAYG;;;;;;;;;;;;;;;;;;gBAuBH,sEAAsE;;gBAEtE;;;;;;;;;;;mBAWG;;;YA4aD,uGAAuG;;;;;;;QAkBzG,uEAAuE;;QAEvE,qEAAqE;;;QAGrE;;;;WAIG;;QAEH;;;;WAIG;;;aA8FH,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F,kFAAkF;AAClF,eAAO,MAAM,6BAA6B;;;;;;;aAOxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB;;;;IAIlC;;;;;;OAMG;;;;;;IAMH;;;;;;;;;OASG;;;;;;;;;;;;;;;;;;;;;;IAGH,wEAAwE;;;;;;;;;;;;IAKxE;;;;OAIG;;IAEH;;;;;;;;;;;;;;;;OAgBG;;;IAGH;;;;OAIG;;IAEH;;;;OAIG;;aAEH,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,mFAAmF;AACnF,eAAO,MAAM,2BAA2B;IACtC,wEAAwE;;;;;;IAMxE,+EAA+E;;IAE/E;;;;OAIG;;;;;;YAvqBH,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6NH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;aAmpBH,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAIrF;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC;;;;;;YAtrB5C,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6NH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;aAmqBH,CAAA;AACF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,WAAW,CAC1D,OAAO,iCAAiC,CACzC,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,8BAA8B;;aAEzC,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAEhG;;;GAGG;AACH,eAAO,MAAM,+BAA+B;;;;;;YAxsB1C,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6NH,4FAA4F;;;YAmB5F;;;;;eAKG;;YAWH;;;;eAIG;;YAIH,kGAAkG;;YAElG,0EAA0E;;YAE1E,kEAAkE;;;;;;;;YAlSlE,+EAA+E;;;;;;;;;;gBA3J7E,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCtE,uEAAuE;;;YAuHvE,+DAA+D;;;;;;;;;;;;;gBAvH/D,uEAAuE;;;YAyHvE,6EAA6E;;;;;;;;;;;;;gBAzH7E,uEAAuE;;;;;gBA8EvE;;;;;;;;;mBASG;;gBAEH;;;;;;;;;;;;mBAYG;;;;;;;;;;;;;;;;;;YAuBH,sEAAsE;;YAEtE;;;;;;;;;;;eAWG;;;;;aAqrBH,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAElG;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;IAGxC,qEAAqE;;IAErE,+EAA+E;;aAE/E,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAE9F;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;IAGzC,2FAA2F;;;IAG3F,sFAAsF;;IAEtF,8DAA8D;;IAE9D,gFAAgF;;aAEhF,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAEhG;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;IACrC,6FAA6F;;;;IAI7F,8FAA8F;;IAE9F;;;OAGG;;IAEH,+EAA+E;;aAE/E,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAExF,kEAAkE;AAClE,eAAO,MAAM,0BAA0B;;;aAGrC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAYxF,0DAA0D;AAC1D,eAAO,MAAM,qCAAqC,8CAA8B,CAAA;AAChF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,WAAW,CACzD,OAAO,qCAAqC,CAC7C,CAAA;AAED,mGAAmG;AACnG,eAAO,MAAM,+BAA+B;IAC1C;;;;;;OAMG;;;IAGH,0GAA0G;;aAE1G,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;GAIG;AACH,eAAO,MAAM,kCAAkC;IAC7C,oFAAoF;;IAEpF,8CAA8C;;IAE9C,4FAA4F;;aAE5F,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC;IAChD,4GAA4G;;IAE5G,mDAAmD;;IAEnD,sFAAsF;;aAEtF,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,WAAW,CACzD,OAAO,qCAAqC,CAC7C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC;IACpD,0GAA0G;;IAE1G,wCAAwC;;IAExC,gFAAgF;;aAEhF,CAAA;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAC7D,OAAO,yCAAyC,CACjD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uCAAuC;IAClD,qFAAqF;;IAErF,yDAAyD;;IAEzD,2FAA2F;;IAE3F,kFAAkF;;aAElF,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAC3D,OAAO,uCAAuC,CAC/C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC;IACjD,kFAAkF;;IAElF,0DAA0D;;IAE1D,4FAA4F;;IAE5F,wFAAwF;;aAExF,CAAA;AACF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,WAAW,CAC1D,OAAO,sCAAsC,CAC9C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kCAAkC;IAC7C,uDAAuD;;IAEvD,sEAAsE;;aAEtE,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEnG;;;;GAIG;AACH,eAAO,MAAM,mCAAmC;IAC9C,0CAA0C;;IAE1C,iCAAiC;;IAEjC,kDAAkD;;aAElD,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CACvD,OAAO,mCAAmC,CAC3C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;IACxC,0EAA0E;;IAE1E,iDAAiD;;aAEjD,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;GAIG;AACH,eAAO,MAAM,kCAAkC;IAC7C,mGAAmG;;IAEnG,yCAAyC;;aAEzC,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEnG;;;;GAIG;AACH,eAAO,MAAM,mCAAmC;IAC9C,4FAA4F;;IAE5F,+CAA+C;;IAE/C,iEAAiE;;IAEjE,oFAAoF;;aAEpF,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CACvD,OAAO,mCAAmC,CAC3C,CAAA;AAED,eAAO,MAAM,gCAAgC;;IAE3C,uFAAuF;;;QAppBvF,oGAAoG;;;;;;;;;;;;QAEpG,4EAA4E;;QAE5E,oFAAoF;;QAEpF;;;;;WAKG;;QAEH;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEH,wGAAwG;;QAExG,sEAAsE;;QAEtE;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAynBH,4FAA4F;;;;;;;;;;;;;;;;;;;;;;;;IAE5F,0GAA0G;;IAE1G,0FAA0F;;QAhM1F,oFAAoF;;QAEpF,8CAA8C;;QAE9C,4FAA4F;;;IA8L5F,2GAA2G;;QA7I3G,qFAAqF;;QAErF,yDAAyD;;QAEzD,2FAA2F;;QAE3F,kFAAkF;;;IAyIlF,4FAA4F;;QAnL5F,4GAA4G;;QAE5G,mDAAmD;;QAEnD,sFAAsF;;;IAiLtF,iGAAiG;;QAnKjG,0GAA0G;;QAE1G,wCAAwC;;QAExC,gFAAgF;;;IAiKhF,0FAA0F;;QA/H1F,kFAAkF;;QAElF,0DAA0D;;QAE1D,4FAA4F;;QAE5F,wFAAwF;;;IA2HxF,kFAAkF;;QA9GlF,uDAAuD;;QAEvD,sEAAsE;;;IA8GtE,6EAA6E;;QAnG7E,0CAA0C;;QAE1C,iCAAiC;;QAEjC,kDAAkD;;;IAiGlD,+FAA+F;;QAlF/F,0EAA0E;;QAE1E,iDAAiD;;;IAkFjD;;;OAGG;;QArDH,mGAAmG;;QAEnG,yCAAyC;;;IAqDzC;;;;OAIG;;IAEH;;;;OAIG;;QApDH,4FAA4F;;QAE5F,+CAA+C;;QAE/C,iEAAiE;;QAEjE,oFAAoF;;;IAgDpF,gDAAgD;;QArPhD;;;;;;WAMG;;;QAGH,0GAA0G;;;aA8O1G,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE/F;;;;GAIG;AACH,eAAO,MAAM,+BAA+B;;;IAG1C,qEAAqE;;IAErE,+EAA+E;;IAE/E,+EAA+E;;IAE/E;;;;;;OAMG;;IAEH;;;;;;;OAOG;;IAEH;;;OAGG;;aAEH,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAElG;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,MAAM,EAAE,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC,EACnC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,MAAM,GACZ,CAAC,CAUH"}

package/dist/environments.js

@@ -147,6 +147,20 @@ export const environmentResponseMappingSchema = v.object({
      * is the only thing to try.
      */
     addressesPath: v.optional(v.string()),
+    /**
+     * The same, for a management API that identifies those balancers by NAME: a string, an array of
+     * strings, or an array of `{ host, label }` objects. The platform resolves each name when it
+     * dials, and grades every address it answers with exactly as a stated address is graded.
+     *
+     * A second path rather than more shapes on {@link addressesPath}, because a bare string there
+     * already means an address and cannot be re-read as a name without guessing: a manifest saying
+     * which kind it publishes is the whole difference between resolving a balancer FQDN and handing
+     * a resolver a non-canonical literal that answers loopback. Declaring both is fine, and the
+     * addresses are then tried ahead of the names; a provider that wants a different order between
+     * the two states them all through `addressesPath` as `{ address }` / `{ host }` objects, which
+     * is the one shape that can interleave them.
+     */
+    hostsPath: v.optional(v.string()),
     statusPath: v.optional(v.string()),
     statusMap: v.optional(v.array(v.object({ from: v.string(), to: environmentStatusSchema }))),
     expiresAtPath: v.optional(v.string()),