expectValue: types.OptionalNone,
		},
		{
			name:        "example_usage_dns1123Subdomain",
			expr:        `format.dns1123Subdomain().validate("apiextensions.k8s.io")`,
			expectValue: types.OptionalNone,
		},
		{
			name:        "example_usage_qualifiedName",
			expr:        `format.qualifiedName().validate("apiextensions.k8s.io/v1beta1")`,
			expectValue: types.OptionalNone,
		},
		{

  return
}

// -----

// CHECK-LABEL: @none
func.func @none(%arg0: tensor<!tf_type.variant<tensor<f32>>>) {
  // CHECK-NOT: Optional
  %0 = "tf.OptionalNone"() : () -> tensor<!tf_type.variant<tensor<f32>>>
  return
}

// -----

// CHECK-LABEL: @partitioned_calls

				"zero": types.OptionalOf(types.IntZero),
			},
			expected: map[string]any{
				"zero": int64(0),
			},
		},
		{
			name: "none",
			fields: map[string]ref.Val{
				"absent": types.OptionalNone,
			},
			expected: map[string]any{
				// right now no way to differ from a plain null.
				// we will need to filter out optional.none() before this conversion.
				"absent": nil,
			},
		},
	} {

		},
		{
			name:        "access existing field, return none",
			expression:  `Object{}.?existing`,
			expectedVal: celtypes.OptionalNone,
		},
		{
			name:        "map non-existing field, return none",
			expression:  `{"foo": 1}[?"bar"]`,
			expectedVal: celtypes.OptionalNone,
		},
		{
			name:        "map existing field, return actual value",
			expression:  `{"foo": 1}[?"foo"]`,

			nameString, ok := name.Value().(string)
			if !ok {
				return types.MaybeNoSuchOverloadErr(name)
			}

			f, ok := ConstantFormats[nameString]
			if !ok {
				return types.OptionalNone
			}
			return types.OptionalOf(f)
		})),
	},
}

func formatValidate(arg1, arg2 ref.Val) ref.Val {
	f, ok := arg1.Value().(*apiservercel.Format)
	if !ok {

                              .HostMemory("string_handle"),                    \
                          data::IteratorFromStringHandleOp);                   \
  REGISTER_KERNEL_BUILDER(Name("OptionalNone").Device(DEVICE),                 \
                          data::OptionalNoneOp);                               \
  REGISTER_KERNEL_BUILDER(Name("OptionalFromValue").Device(DEVICE),            \

// Moves TPUCompileMlir ops as far to the front as possible.
std::unique_ptr<OperationPass<func::FuncOp>> CreateMoveTpuCompileToFrontPass();

// Decomposes OptionalFromValue, OptionalGetValue, OptionalNone,
// and OptionalHasValue
std::unique_ptr<OperationPass<ModuleOp>> CreateDecomposeOptionalsPass();

//===----------------------------------------------------------------------===//
// XlaCallModule

	}
	optionalVA := &validationActivation{
		self:       va.self,
		hasOldSelf: true, // this means the oldSelf variable is defined for CEL to reference, not that it has a value
		oldSelf:    types.OptionalNone,
	}

	if oldObj != nil {
		va.oldSelf = UnstructuredToVal(oldObj, sts) // +k8s:verify-mutation:reason=clone
		va.hasOldSelf = true

}

def DecomposeOptionalsPass : Pass<"tf-decompose-optionals", "ModuleOp"> {
  let summary = "Decomposes ops of the 'Optional' family";
  let description = [{
    Turns OptionalFromValue, OptionalGetValue, OptionalNone,
    and OptionalHasValue into identities.

    For example, if we have:

      %1 = "tf.OptionalFromValue"(%0) : (tensor<f32>) -> !tf_type.variant

  }];

  let arguments = (ins
    TF_VariantTensor:$optional
  );

  let results = (outs
    TF_BoolTensor:$has_value
  );
}

def TF_OptionalNoneOp : TF_Op<"OptionalNone", [Pure]> {
  let summary = "Creates an Optional variant with no value.";

  let arguments = (ins);

  let results = (outs
    TF_VariantTensor:$optional
  );
}