.map { "$it.*" } + "" +
                AnnotationGenerator.ADDITIONAL_DEFAULT_IMPORTS
        return imports.joinToString(separator = "\n") {
            if (it.isBlank()) "" else "import $it"
        }
    }

    private
    inline fun <reified Receiver> groovyReceiverAccessors(): String {
        return groovyReceiverAccessors(Receiver::class)
    }

    private

					result = healEntrySuccess(uint64(version.Size))
				} else {
					bgSeq.countFailed(madmin.HealItemObject)
					result = healEntryFailure(uint64(version.Size))
					if version.VersionID != "" {
						healingLogIf(ctx, fmt.Errorf("unable to heal object %s/%s (version-id=%s): %w",
							bucket, version.Name, version.VersionID, err))
					} else {
						healingLogIf(ctx, fmt.Errorf("unable to heal object %s/%s: %w",

                } else if (logger.isDebugEnabled()) {
                    logger.debug("  Excluded: {}", getId(artifact));
                }
            }
        }

        if (parentImports != null) {
            parentImports = new ArrayList<>(parentImports);
        } else {
            parentImports = new ArrayList<>();
        }

    size: int | None = Body(default=None),
):
    if item_id in items:
        item = items[item_id]
        item["name"] = name
        item["size"] = size
        return item
    else:
        item = {"name": name, "size": size}
        items[item_id] = item

			db.Statement.Settings.Delete("rows")
			db.Statement.Dest, db.Error = db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
		} else {
			db.Statement.Dest = db.Statement.ConnPool.QueryRowContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
		}

		db.RowsAffected = -1
	}

		t.Fatalf("errors happened when query: %v", err)
	} else {
		CheckUser(t, newUser, u1)
	}

	type user struct {
		ID   int `gorm:"primaryKey;->:false"`
		Name string
		Age  int
	}

	var u2 user
	if results := DB.Create(&u2); results.Error != nil {
		t.Fatalf("errors happened when create: %v", results.Error)
	} else if results.RowsAffected != 1 {

                request.addArtifact(pomArtifact);
            } else if (metadata instanceof SnapshotArtifactRepositoryMetadata
                    || metadata instanceof ArtifactRepositoryMetadata) {
                // eaten, handled by repo system
            } else {
                request.addMetadata(new MetadataBridge(metadata));
            }
        }

      tsl::Set_TF_Status_from_Status(status, v2_reader_->status());
      return;
    }
    auto result = BuildV2VarMaps();
    var_to_shape_map_.swap(result.first);
    var_to_data_type_map_.swap(result.second);
  } else {
    reader_.reset(new TensorSliceReader(filename));
    if (!reader_->status().ok()) {
      tsl::Set_TF_Status_from_Status(status, reader_->status());
      return;
    }
    var_to_shape_map_.reset(

                href = "${dsldocUrl.get()}/${className}.html"
            } else if (style == "javadoc") {
                def base = javadocUrl.get()
                def packageName = classMetaData.packageName
                href = "$base/${packageName.replace('.', '/')}/${className.substring(packageName.length()+1)}.html"
            } else {
                throw new InvalidUserDataException("Unknown api link style '$style'.")

            apilink.setAttribute("class", method.getOwnerClass().getClassName());
            apilink.setAttribute("method", method.getOverrideSignature());
            return apilink;
        } else {
            listener.warning(String.format("Could not generate link for method %s", method));
            Element element = document.createElement("UNKNOWN-METHOD");