}

// nestedValueValidationToStructural converts a nested value validation to
// an equivalent structural schema instance.
//
// This lets us avoid needing a separate adaptor for the nested value
// validations, and doesn't cost too much since since we are usually exploring the
// entire schema anyway.
func nestedValueValidationToStructural(nvv *schema.NestedValueValidation) *Structural {

Alexander Zielenski <******@****.***> 1696898977 -0700

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package common

// Schema is the adapted type for an OpenAPI schema that CEL uses.
// This schema does not cover all OpenAPI fields but only these CEL requires
// are exposed as getters.
type Schema interface {
	// Type returns the OpenAPI type.

  LogicalResult matchAndRewriteImplWithSliceAndConcat(
      TF::TensorListSetItemOp op, OpAdaptor adaptor,
      ConversionPatternRewriter &rewriter) const {
    Location loc = op.getLoc();
    Value input = adaptor.getOperands()[0];
    Value index = adaptor.getOperands()[1];
    Value item = adaptor.getOperands()[2];

    IntegerType shape_dtype = rewriter.getIntegerType(32);

  LogicalResult matchAndRewrite(
      TF::UniformDequantizeOp op, TF::UniformDequantizeOpAdaptor adaptor,
      ConversionPatternRewriter &rewriter) const override {
    Value input = adaptor.getInput();

    auto input_quant_type = GetUniformQuantizedType(
        op, op.getInput().getType(), op.getScales(), op.getZeroPoints(),
        /*expressed_type=*/rewriter.getF32Type(), op.getQuantizationMinVal(),

	}

	for _, test := range tests {
		adaptor := NewLeaderHealthzAdaptor(test.adaptorTimeout)
		if adaptor.le != nil {
			t.Errorf("[%s] leaderChecker started with a LeaderElector %v", test.description, adaptor.le)
		}
		if test.elector != nil {
			test.elector.config.WatchDog = adaptor
			adaptor.SetLeaderElection(test.elector)
			if adaptor.le == nil {
				t.Errorf("[%s] adaptor failed to set the LeaderElector", test.description)

template <typename ResultType>
static LogicalResult FoldDivOpInternal(stablehlo::DivOp op,
                                       PatternRewriter& rewriter) {
  auto adaptor = FoldAdaptor::Create(op);
  if (!adaptor.has_value()) {
    return failure();
  }
  auto const_oprs = adaptor.value().OperandData();

  const bool lhs_splat = const_oprs[0].isSplat();
  const bool rhs_splat = const_oprs[1].isSplat();

	"time"
)

// HealthzAdaptor associates the /healthz endpoint with the LeaderElection object.
// It helps deal with the /healthz endpoint being set up prior to the LeaderElection.
// This contains the code needed to act as an adaptor between the leader
// election code the health check code. It allows us to provide health
// status about the leader election. Most specifically about if the leader

          op->getLoc(), op.getOperand().getType(), adaptor.getOperand());
      rewriter.replaceOpWithNewOp<mlir::stablehlo::BitcastConvertOp>(
          op, op.getResult().getType(), output);
    } else {
      // Both input/output are f32. Convert to no-op.
      rewriter.replaceOp(op, adaptor.getOperand());
    }
    return success();
  }
};
}  // namespace

OpFoldResult MaximumOp::fold(FoldAdaptor adaptor) {
  auto lhs_type = getLhs().getType();
  auto rhs_type = getRhs().getType();
  // Only constant fold for float tensors of the same type is implemented.
  if (lhs_type != rhs_type || !IsFloatShapedType(lhs_type)) return nullptr;

  auto lhs = adaptor.getLhs().dyn_cast_or_null<DenseElementsAttr>();
  auto rhs = adaptor.getRhs().dyn_cast_or_null<DenseElementsAttr>();